diff --git a/tools/power-utils/aei_updater.cpp b/tools/power-utils/aei_updater.cpp
new file mode 100644
index 0000000..0567ac9
--- /dev/null
+++ b/tools/power-utils/aei_updater.cpp
@@ -0,0 +1,181 @@
+/**
+ * Copyright © 2024 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "config.h"
+
+#include "aei_updater.hpp"
+
+#include "pmbus.hpp"
+#include "types.hpp"
+#include "updater.hpp"
+#include "utility.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+
+namespace aeiUpdater
+{
+constexpr uint8_t MAX_RETRIES = 0x02;    // Constants for retry limits
+
+constexpr int ISP_STATUS_DELAY = 1200;   // Delay for ISP status check (1.2s)
+constexpr int MEM_WRITE_DELAY = 5000;    // Memory write delay (5s)
+constexpr int MEM_STRETCH_DELAY = 50;    // Delay between writes (50ms)
+constexpr int MEM_COMPLETE_DELAY = 2000; // Delay before completion (2s)
+constexpr int REBOOT_DELAY = 8000;       // Delay for reboot (8s)
+
+constexpr uint8_t I2C_SMBUS_BLOCK_MAX = 0x20; // Max Read bytes from PSU
+constexpr uint8_t FW_READ_BLOCK_SIZE = 0x20;  // Read bytes from FW file
+constexpr uint8_t BLOCK_WRITE_SIZE = 0x25;    // I2C block write size
+constexpr uint8_t READ_SEQ_ST_CML_SIZE = 0x6; // Read sequence and status CML
+                                              // size
+constexpr uint8_t START_SEQUENCE_INDEX = 0x1; // Starting sequence index
+constexpr uint8_t STATUS_CML_INDEX = 0x5;     // Status CML read index
+
+// Register addresses for commands.
+constexpr uint8_t KEY_REGISTER = 0xF6;        // Key register
+constexpr uint8_t STATUS_REGISTER = 0xF7;     // Status register
+constexpr uint8_t ISP_MEMORY_REGISTER = 0xF9; // ISP memory register
+
+// Define AEI ISP status register commands
+constexpr uint8_t CMD_CLEAR_STATUS = 0x0; // Clear the status register
+constexpr uint8_t CMD_RESET_SEQ = 0x01;   // This command will reset ISP OS for
+                                          // another attempt of a sequential
+                                          // programming operation.
+constexpr uint8_t CMD_BOOT_ISP = 0x02; // Boot the In-System Programming System.
+constexpr uint8_t CMD_BOOT_PWR = 0x03; // Attempt to boot the Power Management
+                                       // OS.
+
+// Define AEI ISP response status bit
+constexpr uint8_t B_CHKSUM_ERR = 0x0; // The checksum verification unsuccessful
+constexpr uint8_t B_CHKSUM_SUCCESS = 0x1; // The checksum verification
+                                          // successful.
+constexpr uint8_t B_MEM_ERR = 0x2;        // Memory boundry error indication.
+constexpr uint8_t B_ALIGN_ERR = 0x4;      // Address error indication.
+constexpr uint8_t B_KEY_ERR = 0x8;        // Invalid Key
+constexpr uint8_t B_START_ERR = 0x10;     // Error indicator set at startup.
+constexpr uint8_t B_IMG_MISSMATCH_ERR = 0x20; // Firmware image does not match
+                                              // PSU
+constexpr uint8_t B_ISP_MODE = 0x40;          // ISP mode
+constexpr uint8_t B_ISP_MODE_CHKSUM_GOOD = 0x41; // ISP mode  & good checksum.
+constexpr uint8_t B_PRGM_BUSY = 0x80;            // Write operation in progress.
+
+using namespace phosphor::logging;
+namespace util = phosphor::power::util;
+
+int AeiUpdater::doUpdate()
+{
+    i2cInterface = Updater::getI2C();
+    if (i2cInterface == nullptr)
+    {
+        throw std::runtime_error("I2C interface error");
+    }
+    bool cleanFailedIspMode = false; // Flag to prevent download and continue to
+                                     // restore the PSU to it's original state.
+
+    // Set ISP mode by writing necessary keys and resetting ISP status
+    if (!writeIspKey() || !writeIspMode() || !writeIspStatusReset())
+    {
+        lg2::error("Failed to set ISP key or mode or reset ISP status");
+        cleanFailedIspMode = true;
+    }
+
+    if (cleanFailedIspMode)
+    {
+        return 1;
+    }
+    return 0; // Update successful.
+}
+
+bool AeiUpdater::writeIspKey()
+{
+    // ISP Key to unlock programming mode ( ASCII for "artY").
+    constexpr std::array<uint8_t, 4> unlockData = {0x61, 0x72, 0x74,
+                                                   0x59}; // ISP Key "artY"
+    try
+    {
+        // Send ISP Key to unlock device for firmware update
+        i2cInterface->write(KEY_REGISTER, unlockData.size(), unlockData.data());
+        return true;
+    }
+    catch (const std::exception& e)
+    {
+        // Log failure if I2C write fails.
+        lg2::error("I2C write failed: {ERROR}", "ERROR", e.what());
+        return false;
+    }
+}
+
+bool AeiUpdater::writeIspMode()
+{
+    // Attempt to set device in ISP mode with retries.
+    uint8_t ispStatus = 0x0;
+    for (int retry = 0; retry < MAX_RETRIES; ++retry)
+    {
+        try
+        {
+            // Write command to enter ISP mode.
+            i2cInterface->write(STATUS_REGISTER, CMD_BOOT_ISP);
+            // Delay to allow status register update.
+            updater::internal::delay(ISP_STATUS_DELAY);
+            // Read back status register to confirm ISP mode is active.
+            i2cInterface->read(STATUS_REGISTER, ispStatus);
+
+            if (ispStatus & B_ISP_MODE)
+            {
+                return true;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            // Log I2C error with each retry attempt.
+            lg2::error("I2C error during ISP mode write/read: {ERROR}", "ERROR",
+                       e.what());
+        }
+    }
+    lg2::error("Failed to set ISP Mode");
+    return false; // Failed to set ISP Mode after retries
+}
+
+bool AeiUpdater::writeIspStatusReset()
+{
+    // Reset ISP status register before firmware download.
+    uint8_t ispStatus = 0;
+    try
+    {
+        i2cInterface->write(STATUS_REGISTER,
+                            CMD_RESET_SEQ); // Start reset sequence.
+        for (int retry = 0; retry < MAX_RETRIES; ++retry)
+        {
+            i2cInterface->read(STATUS_REGISTER, ispStatus);
+            if (ispStatus == B_ISP_MODE)
+            {
+                return true; // ISP status reset successfully.
+            }
+            i2cInterface->write(STATUS_REGISTER,
+                                CMD_CLEAR_STATUS); // Clear status if
+                                                   // not reset.
+        }
+    }
+    catch (const std::exception& e)
+    {
+        // Log any errors encountered during reset sequence.
+        lg2::error("I2C Read/Write error during ISP reset: {ERROR}", "ERROR",
+                   e.what());
+    }
+    lg2::error("Failed to reset ISP Status");
+    return false;
+}
+
+} // namespace aeiUpdater