diff --git a/src/NotifyWatch.cpp b/src/NotifyWatch.cpp
new file mode 100644
index 0000000..d4d8faf
--- /dev/null
+++ b/src/NotifyWatch.cpp
@@ -0,0 +1,118 @@
+#include "NotifyWatch.hpp"
+
+#include <sys/inotify.h>
+#include <unistd.h>
+
+#include <sdbusplus/async.hpp>
+
+#include <array>
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
+#include <filesystem>
+#include <memory>
+#include <span>
+#include <string>
+#include <system_error>
+#include <utility>
+
+namespace notify_watch
+{
+
+namespace fs = std::filesystem;
+
+NotifyWatch::NotifyWatch(sdbusplus::async::context& ctx, const std::string& dir,
+                         Callback_t callback) :
+    ctx(ctx), callback(std::move(callback))
+{
+    std::error_code ec = {};
+
+    fs::path dirPath(dir);
+    if (!fs::create_directories(dirPath, ec))
+    {
+        if (ec)
+        {
+            throw std::system_error(ec, "Failed to create directory " + dir);
+        }
+    }
+
+    fd = inotify_init1(IN_NONBLOCK);
+    if (-1 == fd)
+    {
+        throw std::system_error(errno, std::system_category(),
+                                "inotify_init1 failed");
+    }
+
+    wd = inotify_add_watch(fd, dir.c_str(), IN_CLOSE_WRITE);
+    if (-1 == wd)
+    {
+        close(fd);
+        throw std::system_error(errno, std::system_category(),
+                                "inotify_add_watch failed");
+    }
+
+    fdioInstance = std::make_unique<sdbusplus::async::fdio>(ctx, fd);
+    if (!fdioInstance)
+    {
+        throw std::system_error(errno, std::system_category(),
+                                "Failed to create fdio");
+    }
+}
+
+NotifyWatch::~NotifyWatch()
+{
+    if (-1 != fd)
+    {
+        if (-1 != wd)
+        {
+            inotify_rm_watch(fd, wd);
+        }
+        close(fd);
+    }
+}
+
+auto NotifyWatch::readNotifyAsync() -> sdbusplus::async::task<>
+{
+    if (!fdioInstance)
+    {
+        co_return;
+    }
+    co_await fdioInstance->next();
+
+    alignas(inotify_event) std::array<uint8_t, 4096> buffer{};
+
+    auto bytes = read(fd, buffer.data(), buffer.size());
+    if (bytes < 0)
+    {
+        throw std::system_error(errno, std::system_category(),
+                                "Failed to read notify event");
+    }
+
+    for (auto* iter = buffer.data(); iter < buffer.data() + bytes;)
+    {
+        // Bypassed clang tidy warning about reinterpret_cast as cast is being
+        // performed to avoid copying of buffer data.
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        std::span<inotify_event> event{reinterpret_cast<inotify_event*>(iter),
+                                       1};
+        if (((event[0].mask & IN_CLOSE_WRITE) != 0U) &&
+            ((event[0].mask & IN_ISDIR) == 0U))
+        {
+            if (callback)
+            {
+                // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+                std::span<char> name{reinterpret_cast<char*>(event[0].name),
+                                     event[0].len};
+                co_await callback(std::string(name.begin(), name.end()));
+            }
+        }
+        iter += sizeof(inotify_event) + event[0].len;
+    }
+
+    if (!ctx.stop_requested())
+    {
+        ctx.spawn(readNotifyAsync());
+    }
+}
+
+} // namespace notify_watch
diff --git a/src/NotifyWatch.hpp b/src/NotifyWatch.hpp
new file mode 100644
index 0000000..1e1b33e
--- /dev/null
+++ b/src/NotifyWatch.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <sdbusplus/async.hpp>
+
+#include <cerrno>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace notify_watch
+{
+
+class NotifyWatch
+{
+  public:
+    using Callback_t = std::function<sdbusplus::async::task<>(std::string)>;
+
+    NotifyWatch() = delete;
+    explicit NotifyWatch(sdbusplus::async::context& ctx, const std::string& dir,
+                         Callback_t callback);
+    ~NotifyWatch();
+
+    /** @brief Asynchronously watch and notify for any changes to dir */
+    auto readNotifyAsync() -> sdbusplus::async::task<>;
+
+  private:
+    sdbusplus::async::context& ctx;
+    Callback_t callback;
+    int wd = -1;
+    int fd = -1;
+    std::unique_ptr<sdbusplus::async::fdio> fdioInstance;
+};
+
+} // namespace notify_watch
diff --git a/src/cable-monitor/CableConfig.cpp b/src/cable-monitor/CableConfig.cpp
new file mode 100644
index 0000000..2988342
--- /dev/null
+++ b/src/cable-monitor/CableConfig.cpp
@@ -0,0 +1,75 @@
+#include "CableConfig.hpp"
+
+#include <nlohmann/json.hpp>
+#include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/async.hpp>
+
+#include <algorithm>
+#include <exception>
+#include <fstream>
+#include <string>
+
+namespace cable
+{
+
+PHOSPHOR_LOG2_USING;
+
+using json = nlohmann::json;
+
+static auto parseConfigFile(std::string configFile) -> json
+{
+    std::ifstream jsonFile(configFile);
+    if (!jsonFile.is_open())
+    {
+        error("Config file not found: {PATH}", "PATH", configFile);
+        return {};
+    }
+
+    try
+    {
+        return json::parse(jsonFile, nullptr, true);
+    }
+    catch (const json::parse_error& e)
+    {
+        error("Failed to parse config file {PATH}: {ERROR}", "PATH", configFile,
+              "ERROR", e);
+    }
+
+    return {};
+}
+
+auto Config::processConfig(std::string configFile)
+    -> sdbusplus::async::task<Config::Cables>
+{
+    Cables cables{};
+    auto jsonConfig = parseConfigFile(configFile);
+    if (jsonConfig.empty())
+    {
+        co_return cables;
+    }
+
+    static constexpr auto connectedCablesProperty = "ConnectedCables";
+    try
+    {
+        jsonConfig.at(connectedCablesProperty).get_to(cables);
+    }
+    catch (const std::exception& e)
+    {
+        error("Failed to find {PROPERTY} in config, {ERROR}", "PROPERTY",
+              connectedCablesProperty, "ERROR", e);
+        co_return cables;
+    }
+
+    Cables cablesTemp{};
+
+    for (auto cable : cables)
+    {
+        std::replace(cable.begin(), cable.end(), ' ', '_');
+        debug("Config: Cable {NAME}", "NAME", cable);
+        cablesTemp.insert(cable);
+    }
+
+    co_return cablesTemp;
+}
+
+} // namespace cable
diff --git a/src/cable-monitor/CableConfig.hpp b/src/cable-monitor/CableConfig.hpp
new file mode 100644
index 0000000..b8c9fe2
--- /dev/null
+++ b/src/cable-monitor/CableConfig.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <sdbusplus/async.hpp>
+
+#include <set>
+#include <string>
+
+namespace cable
+{
+
+class Config
+{
+  public:
+    static constexpr auto configFileDir = "/var/lib/cablemonitor";
+    static constexpr auto configFileName = "cable-config.json";
+    explicit Config() = default;
+
+    using Cables = std::set<std::string>;
+
+    /** Process the configuration file */
+    static auto processConfig(std::string configFile)
+        -> sdbusplus::async::task<Cables>;
+};
+
+} // namespace cable
diff --git a/src/cable-monitor/CableEvents.cpp b/src/cable-monitor/CableEvents.cpp
new file mode 100644
index 0000000..a7a132e
--- /dev/null
+++ b/src/cable-monitor/CableEvents.cpp
@@ -0,0 +1,50 @@
+#include "CableEvents.hpp"
+
+#include <phosphor-logging/commit.hpp>
+#include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/async.hpp>
+#include <xyz/openbmc_project/State/Cable/event.hpp>
+
+#include <string>
+
+PHOSPHOR_LOG2_USING;
+
+namespace cable
+{
+
+auto Events::generateCableEvent(Type type, std::string name)
+    -> sdbusplus::async::task<>
+{
+    // Added NO_LINT to bypass clang-tidy warning about STDEXEC_ASSERT as clang
+    // seems to be confused about context being uninitialized.
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch)
+    if (type == Type::connected)
+    {
+        auto pendingEvent = pendingEvents.find(name);
+        if (pendingEvent != pendingEvents.end())
+        {
+            co_await lg2::resolve(ctx, pendingEvent->second);
+
+            using CableConnected = sdbusplus::event::xyz::openbmc_project::
+                state::Cable::CableConnected;
+            co_await lg2::commit(ctx, CableConnected("PORT_ID", name));
+            pendingEvents.erase(pendingEvent);
+        }
+    }
+    else if (type == Type::disconnected)
+    {
+        using CableDisconnected = sdbusplus::error::xyz::openbmc_project::
+            state::Cable::CableDisconnected;
+        auto eventPath =
+            co_await lg2::commit(ctx, CableDisconnected("PORT_ID", name));
+        warning("Generate CableDisconnected for {NAME}", "NAME", name);
+        pendingEvents.emplace(name, eventPath);
+    }
+    else
+    {
+        error("Unknown cable event type");
+    }
+    co_return;
+}
+
+} // namespace cable
diff --git a/src/cable-monitor/CableEvents.hpp b/src/cable-monitor/CableEvents.hpp
new file mode 100644
index 0000000..d3303b2
--- /dev/null
+++ b/src/cable-monitor/CableEvents.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <sdbusplus/async.hpp>
+#include <sdbusplus/message/native_types.hpp>
+
+#include <string>
+#include <unordered_map>
+
+namespace cable
+{
+
+class Events
+{
+  public:
+    /** @brief Event type */
+    enum class Type
+    {
+        connected,
+        disconnected,
+        unknown
+    };
+
+    Events() = delete;
+    explicit Events(sdbusplus::async::context& ctx) : ctx(ctx) {}
+
+    /** @brief Generate a cable event */
+    auto generateCableEvent(Type type, std::string name)
+        -> sdbusplus::async::task<>;
+
+  private:
+    /** @brief Map type for event name to log event object path */
+    using event_map_t =
+        std::unordered_map<std::string, sdbusplus::message::object_path>;
+
+    sdbusplus::async::context& ctx;
+    event_map_t pendingEvents;
+};
+
+} // namespace cable
diff --git a/src/cable-monitor/CableMonitor.cpp b/src/cable-monitor/CableMonitor.cpp
new file mode 100644
index 0000000..f57a722
--- /dev/null
+++ b/src/cable-monitor/CableMonitor.cpp
@@ -0,0 +1,193 @@
+#include "CableMonitor.hpp"
+
+#include "CableConfig.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/async.hpp>
+#include <sdbusplus/async/stdexec/__detail/__then.hpp>
+#include <sdbusplus/message/native_types.hpp>
+#include <sdbusplus/server/manager.hpp>
+
+#include <chrono>
+#include <cstring>
+#include <filesystem>
+#include <functional>
+#include <string>
+
+PHOSPHOR_LOG2_USING;
+
+namespace cable
+{
+
+Monitor::Monitor(sdbusplus::async::context& ctx) :
+    ctx(ctx), cableEvents(ctx),
+    entityManager(ctx, {CableInventoryIntf::interface},
+                  std::bind_front(&Monitor::inventoryAddedHandler, this),
+                  std::bind_front(&Monitor::inventoryRemovedHandler, this)),
+    notifyWatch(ctx, Config::configFileDir,
+                std::bind_front(&Monitor::configUpdateHandler, this))
+{
+    ctx.spawn(start());
+}
+
+auto Monitor::inventoryAddedHandler(
+    const sdbusplus::message::object_path& objectPath,
+    const std::string& /*unused*/) -> void
+{
+    debug("Received cable added for {NAME}", "NAME", objectPath);
+    ctx.spawn(processCableAddedAsync(objectPath));
+}
+
+auto Monitor::inventoryRemovedHandler(
+    const sdbusplus::message::object_path& objectPath,
+    const std::string& /*unused*/) -> void
+{
+    debug("Received cable removed for {NAME}", "NAME", objectPath);
+    ctx.spawn(processCableRemovedAsync(objectPath));
+}
+
+auto Monitor::configUpdateHandler(std::string configFileName)
+    -> sdbusplus::async::task<>
+{
+    if (strcmp(Config::configFileName, configFileName.c_str()) != 0)
+    {
+        error("Update config file name {NAME} is not expected", "NAME",
+              configFileName);
+        co_return;
+    }
+    auto configFilePath =
+        std::string(Config::configFileDir) + "/" + configFileName;
+    if (!std::filesystem::exists(configFilePath))
+    {
+        error("Config file {NAME} does not exist", "NAME", configFilePath);
+        co_return;
+    }
+    expectedCables = co_await Config::processConfig(configFilePath);
+    if (expectedCables.empty())
+    {
+        error("No expected cables found in config file {NAME}", "NAME",
+              configFileName);
+        co_return;
+    }
+    co_await entityManager.handleInventoryGet();
+    ctx.spawn(sdbusplus::async::sleep_for(ctx, std::chrono::seconds(5)) |
+              stdexec::then([&]() { reconcileCableData(); }));
+}
+
+auto Monitor::start() -> sdbusplus::async::task<>
+{
+    info("Start cable monitor");
+
+    // Start async handler for cable config update
+    ctx.spawn(notifyWatch.readNotifyAsync());
+
+    // Process the cable config if it already exists
+    auto configFilePath =
+        std::string(Config::configFileDir) + "/" + Config::configFileName;
+    if (std::filesystem::exists(configFilePath))
+    {
+        co_await configUpdateHandler(Config::configFileName);
+    }
+
+    co_return;
+}
+
+auto Monitor::processCableAddedAsync(sdbusplus::message::object_path objectPath)
+    -> sdbusplus::async::task<>
+{
+    auto cableName = objectPath.filename();
+
+    debug("Received cable added for {NAME}", "NAME", cableName);
+
+    if (connectedCables.contains(cableName))
+    {
+        debug("Cable {NAME} is already connected, so skip it", "NAME",
+              cableName);
+        co_return;
+    }
+    else if (expectedCables.empty())
+    {
+        debug("No expected cables yet, so skip cable add for {NAME}", "NAME",
+              cableName);
+        co_return;
+    }
+    else if (!expectedCables.contains(cableName))
+    {
+        debug(
+            "Cable {NAME} is not in expected cables, skip connected event generation",
+            "NAME", cableName);
+        co_return;
+    }
+
+    connectedCables.insert(cableName);
+    co_await cableEvents.generateCableEvent(Events::Type::connected, cableName);
+    debug("New cable {NAME} added", "NAME", cableName);
+
+    co_return;
+}
+
+auto Monitor::processCableRemovedAsync(
+    sdbusplus::message::object_path objectPath) -> sdbusplus::async::task<>
+{
+    auto cableName = objectPath.filename();
+
+    debug("Received cable removed for {NAME}", "NAME", cableName);
+
+    if (expectedCables.empty())
+    {
+        debug("No expected cables yet, so skip cable add for {NAME}", "NAME",
+              cableName);
+        co_return;
+    }
+    else if (!expectedCables.contains(cableName))
+    {
+        debug(
+            "Cable {NAME} is not in expected cables, so skip disconnected event generation",
+            "NAME", cableName);
+        co_return;
+    }
+    else if (!connectedCables.contains(cableName))
+    {
+        debug(
+            "Cable {NAME} is not connected, so skip disconnected event generation",
+            "NAME", cableName);
+        co_return;
+    }
+
+    connectedCables.erase(cableName);
+    co_await cableEvents.generateCableEvent(Events::Type::disconnected,
+                                            cableName);
+    debug("Removed cable {NAME}", "NAME", cableName);
+
+    co_return;
+}
+
+auto Monitor::reconcileCableData() -> void
+{
+    for (const auto& cableName : expectedCables)
+    {
+        if (connectedCables.contains(cableName))
+        {
+            continue;
+        }
+        ctx.spawn(cableEvents.generateCableEvent(Events::Type::disconnected,
+                                                 cableName));
+    }
+}
+
+} // namespace cable
+
+int main()
+{
+    constexpr auto path = "/xyz/openbmc_project/cable_monitor";
+    constexpr auto serviceName = "xyz.openbmc_project.cablemonitor";
+    sdbusplus::async::context ctx;
+    sdbusplus::server::manager_t manager{ctx, path};
+
+    info("Creating cable monitor");
+    cable::Monitor cableMonitor{ctx};
+    ctx.request_name(serviceName);
+
+    ctx.run();
+    return 0;
+}
diff --git a/src/cable-monitor/CableMonitor.hpp b/src/cable-monitor/CableMonitor.hpp
new file mode 100644
index 0000000..3a2d0a0
--- /dev/null
+++ b/src/cable-monitor/CableMonitor.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#include "CableConfig.hpp"
+#include "CableEvents.hpp"
+#include "EntityManagerInterface.hpp"
+#include "NotifyWatch.hpp"
+
+#include <sdbusplus/async.hpp>
+#include <sdbusplus/message/native_types.hpp>
+#include <xyz/openbmc_project/Inventory/Item/Cable/client.hpp>
+
+#include <string>
+
+namespace cable
+{
+
+class Monitor;
+
+using CableInventoryIntf =
+    sdbusplus::client::xyz::openbmc_project::inventory::item::Cable<>;
+
+class Monitor
+{
+  public:
+    Monitor() = delete;
+
+    explicit Monitor(sdbusplus::async::context& ctx);
+
+  private:
+    /** @brief  Callback handler for new interfaces added to inventory */
+    auto inventoryAddedHandler(
+        const sdbusplus::message::object_path& objectPath,
+        const std::string& interfaceName) -> void;
+
+    /** @brief Callback handler for interfaces removed from inventory */
+    auto inventoryRemovedHandler(
+        const sdbusplus::message::object_path& objectPath,
+        const std::string& interfaceName) -> void;
+
+    /** @brief Callback handler for async updates to cable JSON configuration */
+    auto configUpdateHandler(std::string configFileName)
+        -> sdbusplus::async::task<>;
+
+    /** @brief Start the Cable Monitor */
+    auto start() -> sdbusplus::async::task<>;
+
+    /** @brief Asynchronously process cable inventory added */
+    auto processCableAddedAsync(sdbusplus::message::object_path objectPath)
+        -> sdbusplus::async::task<>;
+
+    /** @brief Asynchronously process cable inventory removed */
+    auto processCableRemovedAsync(sdbusplus::message::object_path objectPath)
+        -> sdbusplus::async::task<>;
+
+    /** @brief Reconcile connected and expected cable data */
+    auto reconcileCableData() -> void;
+
+    sdbusplus::async::context& ctx;
+    Config::Cables connectedCables;
+    Config::Cables expectedCables;
+    Events cableEvents;
+    entity_manager::EntityManagerInterface entityManager;
+    notify_watch::NotifyWatch notifyWatch;
+};
+
+} // namespace cable
diff --git a/src/cable-monitor/meson.build b/src/cable-monitor/meson.build
new file mode 100644
index 0000000..de8d5db
--- /dev/null
+++ b/src/cable-monitor/meson.build
@@ -0,0 +1,19 @@
+src_inc = include_directories('..')
+phosphor_dbus_interfaces_dep = dependency('phosphor-dbus-interfaces')
+
+executable(
+    'cablemonitor',
+    'CableMonitor.cpp',
+    'CableConfig.cpp',
+    'CableEvents.cpp',
+    dependencies: [
+        default_deps,
+        utils_dep,
+        phosphor_dbus_interfaces_dep,
+        notifywatch_dep,
+        entitymanagerinterface_dep,
+    ],
+    include_directories: src_inc,
+    install: true,
+    install_dir: get_option('libexecdir') / 'dbus-sensors',
+)
diff --git a/src/meson.build b/src/meson.build
index 0929ba7..44c3040 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -87,6 +87,18 @@
     dependencies: default_deps,
 )
 
+notifywatch_a = static_library(
+    'notifywatch_a',
+    'NotifyWatch.cpp',
+    dependencies: default_deps,
+)
+
+notifywatch_dep = declare_dependency(
+    include_directories: ['.'],
+    link_with: [notifywatch_a],
+    dependencies: default_deps,
+)
+
 peci_incdirs = []
 if not meson.get_compiler('cpp').has_header('linux/peci-ioctl.h')
     peci_incdirs = ['../include']
@@ -156,3 +168,7 @@
 if get_option('leakdetector').allowed()
     subdir('leakdetector')
 endif
+
+if get_option('cable-monitor').allowed()
+    subdir('cable-monitor')
+endif