diff --git a/requester/mctp_endpoint_discovery.cpp b/requester/mctp_endpoint_discovery.cpp
index 1b6cd30..6833684 100644
--- a/requester/mctp_endpoint_discovery.cpp
+++ b/requester/mctp_endpoint_discovery.cpp
@@ -32,13 +32,27 @@
     mctpEndpointRemovedSignal(
         bus, interfacesRemoved(MCTPPath),
         std::bind_front(&MctpDiscovery::removeEndpoints, this)),
+    mctpEndpointPropChangedSignal(
+        bus, propertiesChangedNamespace(MCTPPath, MCTPInterfaceCC),
+        std::bind_front(&MctpDiscovery::propertiesChangedCb, this)),
     handlers(list)
 {
-    getMctpInfos(existingMctpInfos);
+    std::map<MctpInfo, Availability> currentMctpInfoMap;
+    getMctpInfos(currentMctpInfoMap);
+    for (const auto& mapIt : currentMctpInfoMap)
+    {
+        if (mapIt.second)
+        {
+            // Only add the available endpoints to the terminus
+            // Let the propertiesChanged signal tells us when it comes back
+            // to Available again
+            addToExistingMctpInfos(MctpInfos(1, mapIt.first));
+        }
+    }
     handleMctpEndpoints(existingMctpInfos);
 }
 
-void MctpDiscovery::getMctpInfos(MctpInfos& mctpInfos)
+void MctpDiscovery::getMctpInfos(std::map<MctpInfo, Availability>& mctpInfoMap)
 {
     // Find all implementations of the MCTP Endpoint interface
     pldm::utils::GetSubTreeResponse mapperResponse;
@@ -63,13 +77,15 @@
             const MctpEndpointProps& epProps =
                 getMctpEndpointProps(service, path);
             const UUID& uuid = getEndpointUUIDProp(service, path);
+            const Availability& availability =
+                getEndpointConnectivityProp(path);
             auto types = std::get<MCTPMsgTypes>(epProps);
             if (std::find(types.begin(), types.end(), mctpTypePLDM) !=
                 types.end())
             {
-                mctpInfos.emplace_back(
-                    MctpInfo(std::get<eid>(epProps), uuid, "",
-                             std::get<NetworkId>(epProps)));
+                mctpInfoMap[MctpInfo(std::get<eid>(epProps), uuid, "",
+                                     std::get<NetworkId>(epProps))] =
+                    availability;
             }
         }
     }
@@ -128,6 +144,29 @@
     return static_cast<UUID>(emptyUUID);
 }
 
+Availability MctpDiscovery::getEndpointConnectivityProp(const std::string& path)
+{
+    Availability available = false;
+    try
+    {
+        pldm::utils::PropertyValue propertyValue =
+            pldm::utils::DBusHandler().getDbusPropertyVariant(
+                path.c_str(), MCTPConnectivityProp, MCTPInterfaceCC);
+        if (std::get<std::string>(propertyValue) == "Available")
+        {
+            available = true;
+        }
+    }
+    catch (const sdbusplus::exception_t& e)
+    {
+        error(
+            "Error reading Endpoint Connectivity property at path '{PATH}', error - {ERROR}",
+            "PATH", path, "ERROR", e);
+    }
+
+    return available;
+}
+
 void MctpDiscovery::getAddedMctpInfos(sdbusplus::message_t& msg,
                                       MctpInfos& mctpInfos)
 {
@@ -149,6 +188,7 @@
             "ERROR", e);
         return;
     }
+    const Availability& availability = getEndpointConnectivityProp(objPath.str);
 
     /* Get UUID */
     try
@@ -176,6 +216,15 @@
                 auto eid = std::get<mctp_eid_t>(properties.at("EID"));
                 auto types = std::get<std::vector<uint8_t>>(
                     properties.at("SupportedMessageTypes"));
+
+                if (!availability)
+                {
+                    // Log an error message here, but still add it to the
+                    // terminus
+                    error(
+                        "mctpd added a DEGRADED endpoint {EID} networkId {NET} to D-Bus",
+                        "NET", networkId, "EID", static_cast<unsigned>(eid));
+                }
                 if (std::find(types.begin(), types.end(), mctpTypePLDM) !=
                     types.end())
                 {
@@ -222,6 +271,75 @@
     }
 }
 
+void MctpDiscovery::propertiesChangedCb(sdbusplus::message_t& msg)
+{
+    using Interface = std::string;
+    using Property = std::string;
+    using Value = std::string;
+    using Properties = std::map<Property, std::variant<Value>>;
+
+    Interface interface;
+    Properties properties;
+    std::string objPath{};
+    std::string service{};
+
+    try
+    {
+        msg.read(interface, properties);
+        objPath = msg.get_path();
+    }
+    catch (const sdbusplus::exception_t& e)
+    {
+        error(
+            "Error handling Connectivity property changed message, error - {ERROR}",
+            "ERROR", e);
+        return;
+    }
+
+    for (const auto& [key, valueVariant] : properties)
+    {
+        Value propVal = std::get<std::string>(valueVariant);
+        auto availability = (propVal == "Available") ? true : false;
+
+        if (key == MCTPConnectivityProp)
+        {
+            service = pldm::utils::DBusHandler().getService(objPath.c_str(),
+                                                            MCTPInterface);
+            const MctpEndpointProps& epProps =
+                getMctpEndpointProps(service, objPath);
+
+            auto types = std::get<MCTPMsgTypes>(epProps);
+            if (!std::ranges::contains(types, mctpTypePLDM))
+            {
+                return;
+            }
+            const UUID& uuid = getEndpointUUIDProp(service, objPath);
+
+            MctpInfo mctpInfo(std::get<eid>(epProps), uuid, "",
+                              std::get<NetworkId>(epProps));
+            if (!std::ranges::contains(existingMctpInfos, mctpInfo))
+            {
+                if (availability)
+                {
+                    // The endpoint not in existingMctpInfos and is
+                    // available Add it to existingMctpInfos
+                    info(
+                        "Adding Endpoint networkId {NETWORK} ID {EID} by propertiesChanged signal",
+                        "NETWORK", std::get<3>(mctpInfo), "EID",
+                        unsigned(std::get<0>(mctpInfo)));
+                    addToExistingMctpInfos(MctpInfos(1, mctpInfo));
+                    handleMctpEndpoints(MctpInfos(1, mctpInfo));
+                }
+            }
+            else
+            {
+                // The endpoint already in existingMctpInfos
+                updateMctpEndpointAvailability(mctpInfo, availability);
+            }
+        }
+    }
+}
+
 void MctpDiscovery::discoverEndpoints(sdbusplus::message_t& msg)
 {
     MctpInfos addedInfos;
@@ -234,7 +352,12 @@
 {
     MctpInfos mctpInfos;
     MctpInfos removedInfos;
-    getMctpInfos(mctpInfos);
+    std::map<MctpInfo, Availability> currentMctpInfoMap;
+    getMctpInfos(currentMctpInfoMap);
+    for (const auto& mapIt : currentMctpInfoMap)
+    {
+        mctpInfos.push_back(mapIt.first);
+    }
     removeFromExistingMctpInfos(mctpInfos, removedInfos);
     handleRemovedMctpEndpoints(removedInfos);
 }
@@ -261,4 +384,16 @@
     }
 }
 
+void MctpDiscovery::updateMctpEndpointAvailability(const MctpInfo& mctpInfo,
+                                                   Availability availability)
+{
+    for (const auto& handler : handlers)
+    {
+        if (handler)
+        {
+            handler->updateMctpEndpointAvailability(mctpInfo, availability);
+        }
+    }
+}
+
 } // namespace pldm
diff --git a/requester/mctp_endpoint_discovery.hpp b/requester/mctp_endpoint_discovery.hpp
index 086f1cb..6bd3168 100644
--- a/requester/mctp_endpoint_discovery.hpp
+++ b/requester/mctp_endpoint_discovery.hpp
@@ -19,6 +19,8 @@
 constexpr const char* MCTPInterface = "xyz.openbmc_project.MCTP.Endpoint";
 constexpr const char* EndpointUUID = "xyz.openbmc_project.Common.UUID";
 constexpr const char* MCTPPath = "/au/com/codeconstruct/mctp1";
+constexpr const char* MCTPInterfaceCC = "au.com.codeconstruct.MCTP.Endpoint1";
+constexpr const char* MCTPConnectivityProp = "Connectivity";
 
 /** @class MctpDiscoveryHandlerIntf
  *
@@ -30,6 +32,8 @@
   public:
     virtual void handleMctpEndpoints(const MctpInfos& mctpInfos) = 0;
     virtual void handleRemovedMctpEndpoints(const MctpInfos& mctpInfos) = 0;
+    virtual void updateMctpEndpointAvailability(const MctpInfo& mctpInfo,
+                                                Availability availability) = 0;
     virtual ~MctpDiscoveryHandlerIntf() {}
 };
 
@@ -62,6 +66,9 @@
     /** @brief Used to watch for the removed MCTP endpoints */
     sdbusplus::bus::match_t mctpEndpointRemovedSignal;
 
+    /** @brief Used to watch for new MCTP endpoints */
+    sdbusplus::bus::match_t mctpEndpointPropChangedSignal;
+
     /** @brief List of handlers need to notify when new MCTP
      * Endpoint is Added/Removed */
     std::vector<MctpDiscoveryHandlerIntf*> handlers;
@@ -69,6 +76,13 @@
     /** @brief The existing MCTP endpoints */
     MctpInfos existingMctpInfos;
 
+    /** @brief Callback function when the propertiesChanged D-Bus
+     * signal is triggered for MCTP endpoint's properties.
+     *
+     *  @param[in] msg - Data associated with subscribed signal
+     */
+    void propertiesChangedCb(sdbusplus::message_t& msg);
+
     /** @brief Callback function when MCTP endpoints addedInterface
      * D-Bus signal raised.
      *
@@ -97,11 +111,21 @@
      */
     void handleRemovedMctpEndpoints(const MctpInfos& mctpInfos);
 
+    /** @brief Helper function to invoke registered handlers for
+     *  updating the availability status of the MCTP endpoint
+     *
+     *  @param[in] mctpInfo - information of the target endpoint
+     *  @param[in] availability - new availability status
+     */
+    void updateMctpEndpointAvailability(const MctpInfo& mctpInfo,
+                                        Availability availability);
+
     /** @brief Get list of MctpInfos in MCTP control interface.
      *
-     *  @param[in] mctpInfos - information of discovered MCTP endpoints
+     *  @param[in] mctpInfoMap - information of discovered MCTP endpoints
+     *  and the availability status of each endpoint
      */
-    void getMctpInfos(MctpInfos& mctpInfos);
+    void getMctpInfos(std::map<MctpInfo, Availability>& mctpInfoMap);
 
     /** @brief Get list of new MctpInfos in addedInterace D-Bus signal message.
      *
@@ -147,6 +171,16 @@
     UUID getEndpointUUIDProp(const std::string& service,
                              const std::string& path);
 
+    /** @brief Get Endpoint Availability status from `Connectivity` D-Bus
+     *         property in the `au.com.codeconstruct.MCTP.Endpoint1` D-Bus
+     *         interface.
+     *
+     *  @param[in] path - the MCTP endpoints object path
+     *
+     *  @return Availability status: true if active false if inactive
+     */
+    Availability getEndpointConnectivityProp(const std::string& path);
+
     static constexpr uint8_t mctpTypePLDM = 1;
 };
 
diff --git a/requester/test/mctp_endpoint_discovery_test.cpp b/requester/test/mctp_endpoint_discovery_test.cpp
index f955bc0..01e5eb0 100644
--- a/requester/test/mctp_endpoint_discovery_test.cpp
+++ b/requester/test/mctp_endpoint_discovery_test.cpp
@@ -1,5 +1,6 @@
 #include "config.h"
 
+#include "common/types.hpp"
 #include "common/utils.hpp"
 #include "requester/test/mock_mctp_discovery_handler_intf.hpp"
 
@@ -39,12 +40,12 @@
 {
     auto& bus = pldm::utils::DBusHandler::getBus();
     pldm::MockManager manager;
-    pldm::MctpInfos mctpInfos;
+    std::map<pldm::MctpInfo, pldm::Availability> currentMctpInfoMap;
 
     auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
         bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
-    mctpDiscoveryHandler->getMctpInfos(mctpInfos);
-    EXPECT_EQ(mctpInfos.size(), 0);
+    mctpDiscoveryHandler->getMctpInfos(currentMctpInfoMap);
+    EXPECT_EQ(currentMctpInfoMap.size(), 0);
 }
 
 TEST(MctpEndpointDiscoveryTest, goodAddToExistingMctpInfos)
diff --git a/requester/test/mock_mctp_discovery_handler_intf.hpp b/requester/test/mock_mctp_discovery_handler_intf.hpp
index 8aada96..02de8c5 100644
--- a/requester/test/mock_mctp_discovery_handler_intf.hpp
+++ b/requester/test/mock_mctp_discovery_handler_intf.hpp
@@ -15,6 +15,9 @@
                 (override));
     MOCK_METHOD(void, handleRemovedMctpEndpoints, (const MctpInfos& mctpInfos),
                 (override));
+    MOCK_METHOD(void, updateMctpEndpointAvailability,
+                (const MctpInfo& mctpInfo, Availability availability),
+                (override));
 };
 
 } // namespace pldm