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',
+)