diff --git a/extensions/openpower-pels/data_interface.cpp b/extensions/openpower-pels/data_interface.cpp
index 8b63726..351805c 100644
--- a/extensions/openpower-pels/data_interface.cpp
+++ b/extensions/openpower-pels/data_interface.cpp
@@ -34,6 +34,8 @@
 {
 constexpr auto objectMapper = "/xyz/openbmc_project/object_mapper";
 constexpr auto systemInv = "/xyz/openbmc_project/inventory/system";
+constexpr auto bmcState = "/xyz/openbmc_project/state/bmc0";
+constexpr auto chassisState = "/xyz/openbmc_project/state/chassis0";
 constexpr auto hostState = "/xyz/openbmc_project/state/host0";
 constexpr auto pldm = "/xyz/openbmc_project/pldm";
 constexpr auto enableHostPELs =
@@ -48,6 +50,9 @@
 constexpr auto osStatus = "xyz.openbmc_project.State.OperatingSystem.Status";
 constexpr auto pldmRequester = "xyz.openbmc_project.PLDM.Requester";
 constexpr auto enable = "xyz.openbmc_project.Object.Enable";
+constexpr auto bmcState = "xyz.openbmc_project.State.BMC";
+constexpr auto chassisState = "xyz.openbmc_project.State.Chassis";
+constexpr auto hostState = "xyz.openbmc_project.State.Host";
 } // namespace interface
 
 using namespace sdbusplus::xyz::openbmc_project::State::OperatingSystem::server;
@@ -85,11 +90,11 @@
             if ((status == Status::OSStatus::BootComplete) ||
                 (status == Status::OSStatus::Standby))
             {
-                setHostState(true);
+                setHostUp(true);
             }
             else
             {
-                setHostState(false);
+                setHostUp(false);
             }
         }));
 
@@ -99,6 +104,37 @@
         [this](const auto& value) {
             this->_sendPELsToHost = std::get<bool>(value);
         }));
+
+    // Watch the BMCState property
+    _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
+        bus, object_path::bmcState, interface::bmcState, "CurrentBMCState",
+        *this, [this](const auto& value) {
+            this->_bmcState = std::get<std::string>(value);
+        }));
+
+    // Watch the chassis current and requested power state properties
+    _properties.emplace_back(std::make_unique<InterfaceWatcher<DataInterface>>(
+        bus, object_path::chassisState, interface::chassisState, *this,
+        [this](const auto& properties) {
+            auto state = properties.find("CurrentPowerState");
+            if (state != properties.end())
+            {
+                this->_chassisState = std::get<std::string>(state->second);
+            }
+
+            auto trans = properties.find("RequestedPowerTransition");
+            if (trans != properties.end())
+            {
+                this->_chassisTransition = std::get<std::string>(trans->second);
+            }
+        }));
+
+    // Watch the CurrentHostState property
+    _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
+        bus, object_path::hostState, interface::hostState, "CurrentHostState",
+        *this, [this](const auto& value) {
+            this->_hostState = std::get<std::string>(value);
+        }));
 }
 
 DBusPropertyMap
diff --git a/extensions/openpower-pels/data_interface.hpp b/extensions/openpower-pels/data_interface.hpp
index b3ed60d..19da482 100644
--- a/extensions/openpower-pels/data_interface.hpp
+++ b/extensions/openpower-pels/data_interface.hpp
@@ -173,16 +173,57 @@
         return _sendPELsToHost;
     }
 
+    /**
+     * @brief Returns the BMC state
+     *
+     * @return std::string - The BMC state property value
+     */
+    virtual std::string getBMCState() const
+    {
+        return _bmcState;
+    }
+
+    /**
+     * @brief Returns the Chassis state
+     *
+     * @return std::string - The chassis state property value
+     */
+    virtual std::string getChassisState() const
+    {
+        return _chassisState;
+    }
+
+    /**
+     * @brief Returns the chassis requested power
+     *        transition value.
+     *
+     * @return std::string - The chassis transition property
+     */
+    virtual std::string getChassisTransition() const
+    {
+        return _chassisTransition;
+    }
+
+    /**
+     * @brief Returns the Host state
+     *
+     * @return std::string - The Host state property value
+     */
+    virtual std::string getHostState() const
+    {
+        return _hostState;
+    }
+
   protected:
     /**
      * @brief Sets the host on/off state and runs any
      *        callback functions (if there was a change).
      */
-    void setHostState(bool newState)
+    void setHostUp(bool hostUp)
     {
-        if (_hostUp != newState)
+        if (_hostUp != hostUp)
         {
-            _hostUp = newState;
+            _hostUp = hostUp;
 
             for (auto& [name, func] : _hostChangeCallbacks)
             {
@@ -248,6 +289,26 @@
      * This is usually set to false in manufacturing test.
      */
     bool _sendPELsToHost = true;
+
+    /**
+     * @brief The BMC state property
+     */
+    std::string _bmcState;
+
+    /**
+     * @brief The Chassis current power state property
+     */
+    std::string _chassisState;
+
+    /**
+     * @brief The Chassis requested power transition property
+     */
+    std::string _chassisTransition;
+
+    /**
+     * @brief The host state property
+     */
+    std::string _hostState;
 };
 
 /**
diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index e560d5e..60821b6 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -377,6 +377,24 @@
     json["BMC Version ID"] = std::move(id);
 }
 
+std::string lastSegment(char separator, std::string data)
+{
+    auto pos = data.find_last_of(separator);
+    if (pos != std::string::npos)
+    {
+        data = data.substr(pos + 1);
+    }
+
+    return data;
+}
+
+void addStatesToJSON(nlohmann::json& json, const DataInterfaceBase& dataIface)
+{
+    json["BMCState"] = lastSegment('.', dataIface.getBMCState());
+    json["ChassisState"] = lastSegment('.', dataIface.getChassisState());
+    json["HostState"] = lastSegment('.', dataIface.getHostState());
+}
+
 std::unique_ptr<UserData>
     makeSysInfoUserDataSection(const AdditionalData& ad,
                                const DataInterfaceBase& dataIface)
@@ -385,6 +403,7 @@
 
     addProcessNameToJSON(json, ad.getValue("_PID"), dataIface);
     addBMCFWVersionIDToJSON(json, dataIface);
+    addStatesToJSON(json, dataIface);
 
     return makeJSONUserDataSection(json);
 }
diff --git a/test/openpower-pels/mocks.hpp b/test/openpower-pels/mocks.hpp
index 5c3bdb1..8fb6506 100644
--- a/test/openpower-pels/mocks.hpp
+++ b/test/openpower-pels/mocks.hpp
@@ -25,10 +25,13 @@
     MOCK_METHOD(std::string, getBMCFWVersion, (), (const override));
     MOCK_METHOD(std::string, getBMCFWVersionID, (), (const override));
     MOCK_METHOD(bool, getHostPELEnablement, (), (const override));
+    MOCK_METHOD(std::string, getBMCState, (), (const override));
+    MOCK_METHOD(std::string, getChassisState, (), (const override));
+    MOCK_METHOD(std::string, getHostState, (), (const override));
 
     void changeHostState(bool newState)
     {
-        setHostState(newState);
+        setHostUp(newState);
     }
 
     void setHMCManaged(bool managed)
diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index 2cf58d7..8832038 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -319,6 +319,9 @@
     MockDataInterface dataIface;
 
     EXPECT_CALL(dataIface, getBMCFWVersionID()).WillOnce(Return("ABCD1234"));
+    EXPECT_CALL(dataIface, getBMCState()).WillOnce(Return("State.Ready"));
+    EXPECT_CALL(dataIface, getChassisState()).WillOnce(Return("State.On"));
+    EXPECT_CALL(dataIface, getHostState()).WillOnce(Return("State.Off"));
 
     std::string pid = "_PID=" + std::to_string(getpid());
     std::vector<std::string> ad{pid};
@@ -343,6 +346,15 @@
 
     auto version = json["BMC Version ID"].get<std::string>();
     EXPECT_EQ(version, "ABCD1234");
+
+    auto state = json["BMCState"].get<std::string>();
+    EXPECT_EQ(state, "Ready");
+
+    state = json["ChassisState"].get<std::string>();
+    EXPECT_EQ(state, "On");
+
+    state = json["HostState"].get<std::string>();
+    EXPECT_EQ(state, "Off");
 }
 
 // Test that the sections that override