diff --git a/extensions/openpower-pels/data_interface.cpp b/extensions/openpower-pels/data_interface.cpp
index f84e80f..74da2e2 100644
--- a/extensions/openpower-pels/data_interface.cpp
+++ b/extensions/openpower-pels/data_interface.cpp
@@ -34,6 +34,7 @@
 {
 constexpr auto objectMapper = "/xyz/openbmc_project/object_mapper";
 constexpr auto systemInv = "/xyz/openbmc_project/inventory/system";
+constexpr auto chassisInv = "/xyz/openbmc_project/inventory/system/chassis";
 constexpr auto baseInv = "/xyz/openbmc_project/inventory";
 constexpr auto bmcState = "/xyz/openbmc_project/state/bmc0";
 constexpr auto chassisState = "/xyz/openbmc_project/state/chassis0";
@@ -58,6 +59,8 @@
     "xyz.openbmc_project.Inventory.Item.Board.Motherboard";
 constexpr auto viniRecordVPD = "com.ibm.ipzvpd.VINI";
 constexpr auto locCode = "com.ibm.ipzvpd.Location";
+constexpr auto invCompatible =
+    "xyz.openbmc_project.Inventory.Decorator.Compatible";
 } // namespace interface
 
 using namespace sdbusplus::xyz::openbmc_project::State::OperatingSystem::server;
@@ -142,6 +145,13 @@
         *this, [this](const auto& value) {
             this->_hostState = std::get<std::string>(value);
         }));
+
+    // Watch the compatible system names property
+    _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
+        bus, object_path::chassisInv, interface::invCompatible, "Names", *this,
+        [this](const auto& value) {
+            this->_systemNames = std::get<std::vector<std::string>>(value);
+        }));
 }
 
 DBusPropertyMap
diff --git a/extensions/openpower-pels/data_interface.hpp b/extensions/openpower-pels/data_interface.hpp
index d6153b0..a2dd8f2 100644
--- a/extensions/openpower-pels/data_interface.hpp
+++ b/extensions/openpower-pels/data_interface.hpp
@@ -235,15 +235,13 @@
         getLocationCode(const std::string& inventoryPath) const = 0;
 
     /**
-     * @brief Gets the system type from Entity Manager
+     * @brief Get the list of system type names the system is called.
      *
-     * @param[in] std::string - The system type string
+     * @return std::vector<std::string> - The list of names
      */
-    virtual std::string getSystemType() const
+    virtual const std::vector<std::string>& getSystemNames() const
     {
-        // TODO, not implemented by entity manager yet, but adding now
-        // so it can be mocked.
-        return _systemType;
+        return _systemNames;
     }
 
   protected:
@@ -348,9 +346,9 @@
     std::string _motherboardCCIN;
 
     /**
-     * @brief The system type
+     * @brief The compatible system names array
      */
-    std::string _systemType;
+    std::vector<std::string> _systemNames;
 };
 
 /**
diff --git a/extensions/openpower-pels/dbus_types.hpp b/extensions/openpower-pels/dbus_types.hpp
index 1a95c8b..8743f8f 100644
--- a/extensions/openpower-pels/dbus_types.hpp
+++ b/extensions/openpower-pels/dbus_types.hpp
@@ -9,7 +9,8 @@
 namespace openpower::pels
 {
 
-using DBusValue = std::variant<std::string, bool, std::vector<uint8_t>>;
+using DBusValue = std::variant<std::string, bool, std::vector<uint8_t>,
+                               std::vector<std::string>>;
 using DBusProperty = std::string;
 using DBusInterface = std::string;
 using DBusService = std::string;
diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp
index 9b2262d..22cdc27 100644
--- a/extensions/openpower-pels/registry.cpp
+++ b/extensions/openpower-pels/registry.cpp
@@ -335,8 +335,9 @@
  *        ]
  *    }
  */
-const nlohmann::json& findCalloutList(const nlohmann::json& json,
-                                      const std::string& systemType)
+const nlohmann::json&
+    findCalloutList(const nlohmann::json& json,
+                    const std::vector<std::string>& systemNames)
 {
     const nlohmann::json* callouts = nullptr;
 
@@ -352,7 +353,9 @@
     {
         if (calloutList.contains("System"))
         {
-            if (systemType == calloutList["System"].get<std::string>())
+            if (std::find(systemNames.begin(), systemNames.end(),
+                          calloutList["System"].get<std::string>()) !=
+                systemNames.end())
             {
                 callouts = &calloutList["CalloutList"];
                 break;
@@ -367,13 +370,16 @@
 
     if (!callouts)
     {
+        std::string types;
+        std::for_each(systemNames.begin(), systemNames.end(),
+                      [&types](const auto& t) { types += t + '|'; });
         log<level::WARNING>(
-            "No matching system type entry or default system type entry "
+            "No matching system name entry or default system name entry "
             " for PEL callout list",
-            entry("SYSTEMTYPE=%s", systemType.c_str()));
+            entry("SYSTEMNAMES=%s", types.c_str()));
 
         throw std::runtime_error{
-            "Could not find a CalloutList JSON for this error and system type"};
+            "Could not find a CalloutList JSON for this error and system name"};
     }
 
     return *callouts;
@@ -451,17 +457,18 @@
  *    ]
  *
  * @param[in] json - The callout JSON
- * @param[in] systemType - The system type from EntityManager
+ * @param[in] systemNames - List of compatible system type names
  *
  * @return std::vector<RegistryCallout> - The callouts to use
  */
-std::vector<RegistryCallout> getCalloutsWithoutAD(const nlohmann::json& json,
-                                                  const std::string& systemType)
+std::vector<RegistryCallout>
+    getCalloutsWithoutAD(const nlohmann::json& json,
+                         const std::vector<std::string>& systemNames)
 {
     std::vector<RegistryCallout> calloutEntries;
 
     // Find the CalloutList to use based on the system type
-    const auto& calloutList = findCalloutList(json, systemType);
+    const auto& calloutList = findCalloutList(json, systemNames);
 
     // We finally found the callouts, make the objects.
     for (const auto& callout : calloutList)
@@ -503,14 +510,14 @@
  * entry used when there is no AdditionalData key.
  *
  * @param[in] json - The callout JSON
- * @param[in] systemType - The system type from EntityManager
+ * @param[in] systemNames - List of compatible system type names
  * @param[in] additionalData - The AdditionalData property
  *
  * @return std::vector<RegistryCallout> - The callouts to use
  */
 std::vector<RegistryCallout>
     getCalloutsUsingAD(const nlohmann::json& json,
-                       const std::string& systemType,
+                       const std::vector<std::string>& systemNames,
                        const AdditionalData& additionalData)
 {
     // This indicates which AD field we'll be using
@@ -550,7 +557,7 @@
     }
 
     // Proceed to find the callouts possibly based on system type.
-    return getCalloutsWithoutAD((*it)["Callouts"], systemType);
+    return getCalloutsWithoutAD((*it)["Callouts"], systemNames);
 }
 
 } // namespace helper
@@ -725,18 +732,18 @@
 
 std::vector<RegistryCallout>
     Registry::getCallouts(const nlohmann::json& calloutJSON,
-                          const std::string& systemType,
+                          const std::vector<std::string>& systemNames,
                           const AdditionalData& additionalData)
 {
     // The JSON may either use an AdditionalData key
     // as an index, or not.
     if (helper::calloutUsesAdditionalData(calloutJSON))
     {
-        return helper::getCalloutsUsingAD(calloutJSON, systemType,
+        return helper::getCalloutsUsingAD(calloutJSON, systemNames,
                                           additionalData);
     }
 
-    return helper::getCalloutsWithoutAD(calloutJSON, systemType);
+    return helper::getCalloutsWithoutAD(calloutJSON, systemNames);
 }
 
 } // namespace message
diff --git a/extensions/openpower-pels/registry.hpp b/extensions/openpower-pels/registry.hpp
index b145311..673e2c2 100644
--- a/extensions/openpower-pels/registry.hpp
+++ b/extensions/openpower-pels/registry.hpp
@@ -274,14 +274,14 @@
      * Throws exceptions on failures.
      *
      * @param[in] calloutJSON - Where to look up the  callouts
-     * @param[in] systemType - The system type from EntityManager
+     * @param[in] systemNames - List of compatible system type names
      * @param[in] additionalData - The AdditionalData property
      *
      * @return std::vector<RegistryCallout> - The callouts to use
      */
     static std::vector<RegistryCallout>
         getCallouts(const nlohmann::json& calloutJSON,
-                    const std::string& systemType,
+                    const std::vector<std::string>& systemNames,
                     const AdditionalData& additionalData);
 
   private:
diff --git a/extensions/openpower-pels/src.cpp b/extensions/openpower-pels/src.cpp
index c2edd90..13a3ae5 100644
--- a/extensions/openpower-pels/src.cpp
+++ b/extensions/openpower-pels/src.cpp
@@ -571,10 +571,10 @@
 {
     try
     {
-        auto systemType = dataIface.getSystemType();
+        auto systemNames = dataIface.getSystemNames();
 
         auto regCallouts = message::Registry::getCallouts(
-            regEntry.callouts.value(), systemType, additionalData);
+            regEntry.callouts.value(), systemNames, additionalData);
 
         for (const auto& regCallout : regCallouts)
         {
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index 07c3de3..0e53acf 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -70,7 +70,7 @@
     {
         // Find the severity possibly dependent on the system type.
         auto sev =
-            getSeverity(entry.severity.value(), dataIface.getSystemType());
+            getSeverity(entry.severity.value(), dataIface.getSystemNames());
         if (sev)
         {
             _eventSeverity = *sev;
@@ -78,11 +78,15 @@
         else
         {
             // Someone screwed up the message registry.
+            std::string types;
+            const auto& compatibles = dataIface.getSystemNames();
+            std::for_each(compatibles.begin(), compatibles.end(),
+                          [&types](const auto& t) { types += t + '|'; });
+
             log<level::ERR>(
-                "No severity entry found for this error and system type",
+                "No severity entry found for this error and system name",
                 phosphor::logging::entry("ERROR=%s", entry.name.c_str()),
-                phosphor::logging::entry("SYSTEMTYPE=%s",
-                                         dataIface.getSystemType().c_str()));
+                phosphor::logging::entry("SYSTEMNAMES=%s", types.c_str()));
 
             // Have to choose something, just use informational.
             _eventSeverity = 0;
@@ -194,7 +198,7 @@
 
 std::optional<uint8_t> UserHeader::getSeverity(
     const std::vector<message::RegistrySeverity>& severities,
-    const std::string& systemType) const
+    const std::vector<std::string>& systemNames) const
 {
     const uint8_t* s = nullptr;
 
@@ -202,7 +206,8 @@
     // entry (where no system type is specified).
     for (const auto& sev : severities)
     {
-        if (sev.system == systemType)
+        if (std::find(systemNames.begin(), systemNames.end(), sev.system) !=
+            systemNames.end())
         {
             s = &sev.severity;
             break;
diff --git a/extensions/openpower-pels/user_header.hpp b/extensions/openpower-pels/user_header.hpp
index a033ac0..50c5824 100644
--- a/extensions/openpower-pels/user_header.hpp
+++ b/extensions/openpower-pels/user_header.hpp
@@ -244,11 +244,11 @@
      *
      * @param[in] severities - The array of {systype, severity}
      *                         structures to find an entry in.
-     * @param[in] systemType - The system type from DataInterface.
+     * @param[in] systemNames - List of compatible system type names
      */
     std::optional<uint8_t>
         getSeverity(const std::vector<message::RegistrySeverity>& severities,
-                    const std::string& systemType) const;
+                    const std::vector<std::string>& systemNames) const;
     /**
      * @brief The subsystem associated with the event.
      */