diff --git a/extensions/openpower-pels/pldm_interface.cpp b/extensions/openpower-pels/pldm_interface.cpp
index 87edb1c..8fa7c18 100644
--- a/extensions/openpower-pels/pldm_interface.cpp
+++ b/extensions/openpower-pels/pldm_interface.cpp
@@ -17,6 +17,7 @@
 
 #include <libpldm/base.h>
 #include <libpldm/file_io.h>
+#include <systemd/sd-bus.h>
 #include <unistd.h>
 
 #include <fstream>
@@ -25,6 +26,21 @@
 namespace openpower::pels
 {
 
+namespace service
+{
+constexpr auto pldm = "xyz.openbmc_project.PLDM";
+}
+
+namespace object_path
+{
+constexpr auto pldm = "/xyz/openbmc_project/pldm";
+}
+
+namespace interface
+{
+constexpr auto pldm_requester = "xyz.openbmc_project.PLDM.Requester";
+}
+
 using namespace phosphor::logging;
 using namespace sdeventplus;
 using namespace sdeventplus::source;
@@ -36,6 +52,7 @@
 
 PLDMInterface::~PLDMInterface()
 {
+    sd_bus_unref(_bus);
     closeFD();
 }
 
@@ -84,7 +101,60 @@
     }
 }
 
-CmdStatus PLDMInterface::sendNewLogCmd(uint32_t id, uint32_t size)
+void PLDMInterface::instanceIDCallback(sd_bus_message* msg)
+{
+    if (!_inProgress)
+    {
+        // A cancelCmd was run, just return
+        log<level::INFO>(
+            "A command was canceled while waiting for the instance ID");
+        return;
+    }
+
+    bool failed = false;
+
+    auto rc = sd_bus_message_get_errno(msg);
+    if (rc)
+    {
+        log<level::ERR>("GetInstanceId D-Bus method failed",
+                        entry("ERRNO=%d", rc));
+        failed = true;
+    }
+    else
+    {
+        uint8_t id;
+        rc = sd_bus_message_read_basic(msg, 'y', &id);
+        if (rc < 0)
+        {
+            log<level::ERR>("Could not read instance ID out of message",
+                            entry("ERROR=%d", rc));
+            failed = true;
+        }
+        else
+        {
+            _instanceID = id;
+        }
+    }
+
+    if (failed)
+    {
+        _inProgress = false;
+        callResponseFunc(ResponseStatus::failure);
+    }
+    else
+    {
+        startCommand();
+    }
+}
+
+int iidCallback(sd_bus_message* msg, void* data, sd_bus_error* err)
+{
+    auto* interface = static_cast<PLDMInterface*>(data);
+    interface->instanceIDCallback(msg);
+    return 0;
+}
+
+void PLDMInterface::startCommand()
 {
     try
     {
@@ -92,23 +162,59 @@
 
         open();
 
-        readInstanceID();
-
         registerReceiveCallback();
 
-        doSend(id, size);
+        doSend();
+
+        _receiveTimer.restartOnce(_receiveTimeout);
     }
     catch (const std::exception& e)
     {
-        closeFD();
+        cleanupCmd();
 
+        callResponseFunc(ResponseStatus::failure);
+    }
+}
+
+void PLDMInterface::startReadInstanceID()
+{
+    auto rc = sd_bus_call_method_async(
+        _bus, NULL, service::pldm, object_path::pldm, interface::pldm_requester,
+        "GetInstanceId", iidCallback, this, "y", _eid);
+
+    if (rc < 0)
+    {
+        log<level::ERR>("Error calling sd_bus_call_method_async",
+                        entry("RC=%d", rc), entry("MSG=%s", strerror(-rc)));
+        throw std::exception{};
+    }
+}
+
+CmdStatus PLDMInterface::sendNewLogCmd(uint32_t id, uint32_t size)
+{
+    _pelID = id;
+    _pelSize = size;
+    _inProgress = true;
+
+    try
+    {
+        // Kick off the async call to get the instance ID if
+        // necessary, otherwise start the command itself.
+        if (!_instanceID)
+        {
+            startReadInstanceID();
+        }
+        else
+        {
+            startCommand();
+        }
+    }
+    catch (const std::exception& e)
+    {
         _inProgress = false;
-        _source.reset();
         return CmdStatus::failure;
     }
 
-    _inProgress = true;
-    _receiveTimer.restartOnce(_receiveTimeout);
     return CmdStatus::success;
 }
 
@@ -121,30 +227,16 @@
                   std::placeholders::_3));
 }
 
-void PLDMInterface::readInstanceID()
-{
-    try
-    {
-        _instanceID = _dataIface.getPLDMInstanceID(_eid);
-    }
-    catch (const std::exception& e)
-    {
-        log<level::ERR>(
-            "Failed to get instance ID from PLDM Requester D-Bus daemon",
-            entry("ERROR=%s", e.what()));
-        throw;
-    }
-}
-
-void PLDMInterface::doSend(uint32_t id, uint32_t size)
+void PLDMInterface::doSend()
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(pelFileType) +
-                            sizeof(id) + sizeof(uint64_t)>
+                            sizeof(_pelID) + sizeof(uint64_t)>
         requestMsg;
 
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-    auto rc = encode_new_file_req(_instanceID, pelFileType, id, size, request);
+    auto rc = encode_new_file_req(*_instanceID, pelFileType, _pelID, _pelSize,
+                                  request);
     if (rc != PLDM_SUCCESS)
     {
         log<level::ERR>("encode_new_file_req failed", entry("RC=%d", rc));
@@ -173,7 +265,7 @@
     size_t responseSize = 0;
     ResponseStatus status = ResponseStatus::success;
 
-    auto rc = pldm_recv(_eid, fd, _instanceID, &responseMsg, &responseSize);
+    auto rc = pldm_recv(_eid, fd, *_instanceID, &responseMsg, &responseSize);
     if (rc < 0)
     {
         if (rc == PLDM_REQUESTER_INSTANCE_ID_MISMATCH)
@@ -196,10 +288,10 @@
         responseMsg = nullptr;
     }
 
-    _inProgress = false;
-    _receiveTimer.setEnabled(false);
-    closeFD();
-    _source.reset();
+    cleanupCmd();
+
+    // Can't use this instance ID anymore.
+    _instanceID = std::nullopt;
 
     if (status == ResponseStatus::success)
     {
@@ -236,13 +328,22 @@
 void PLDMInterface::receiveTimerExpired()
 {
     log<level::ERR>("Timed out waiting for PLDM response");
-    cancelCmd();
+
+    // Cleanup, but keep the instance ID because the host didn't
+    // respond so we can still use it.
+    cleanupCmd();
 
     callResponseFunc(ResponseStatus::failure);
 }
 
 void PLDMInterface::cancelCmd()
 {
+    _instanceID = std::nullopt;
+    cleanupCmd();
+}
+
+void PLDMInterface::cleanupCmd()
+{
     _inProgress = false;
     _source.reset();
 
diff --git a/extensions/openpower-pels/pldm_interface.hpp b/extensions/openpower-pels/pldm_interface.hpp
index 0d679a1..61bb2a4 100644
--- a/extensions/openpower-pels/pldm_interface.hpp
+++ b/extensions/openpower-pels/pldm_interface.hpp
@@ -42,6 +42,8 @@
             event,
             std::bind(std::mem_fn(&PLDMInterface::receiveTimerExpired), this))
     {
+        sd_bus_default(&_bus);
+
         readEID();
     }
 
@@ -54,6 +56,9 @@
      * @brief Kicks off the send of the 'new file available' command
      *        to send up the ID and size of the new PEL.
      *
+     * It starts by issuing the async D-Bus method call to read the
+     * instance ID.
+     *
      * @param[in] id - The PEL ID
      * @param[in] size - The PEL size in bytes
      *
@@ -63,9 +68,30 @@
 
     /**
      * @brief Cancels waiting for a command response
+     *
+     * This will clear the instance ID so the next command
+     * will request a new one.
      */
     void cancelCmd() override;
 
+    /**
+     * @brief Cleans up so that a new command is ready to be sent.
+     *
+     * Does not clear the instance ID.
+     */
+    void cleanupCmd();
+
+    /**
+     * @brief Gets called on the async D-Bus method response to
+     *        getting the PLDM instance ID.
+     *
+     * It will read the instance ID out of the message and then
+     * continue on with sending the new log command to the host.
+     *
+     * @param[in] msg - The message containing the instance ID.
+     */
+    void instanceIDCallback(sd_bus_message* msg);
+
   private:
     /**
      * @brief The asynchronous callback for getting the response
@@ -107,18 +133,15 @@
     void open();
 
     /**
-     * @brief Reads the PLDM instance ID to use for the upcoming
-     *        command.
+     * @brief Makes the async D-Bus method call to read the PLDM instance
+     *        ID needed to send PLDM commands.
      */
-    void readInstanceID();
+    void startReadInstanceID();
 
     /**
      * @brief Encodes and sends the PLDM 'new file available' cmd
-     *
-     * @param[in] id - The PEL ID
-     * @param[in] size - The PEL size in bytes
      */
-    void doSend(uint32_t id, uint32_t size);
+    void doSend();
 
     /**
      * @brief Closes the PLDM file descriptor
@@ -126,14 +149,26 @@
     void closeFD();
 
     /**
+     * @brief Kicks off the send of the 'new file available' command
+     *        to send the ID and size of a PEL after the instance ID
+     *        has been retrieved.
+     */
+    void startCommand();
+
+    /**
      * @brief The MCTP endpoint ID
      */
     mctp_eid_t _eid;
 
     /**
      * @brief The PLDM instance ID of the current command
+     *
+     * A new ID will be used for every command.
+     *
+     * If there are command failures, the same instance ID can be
+     * used on retries only if the host didn't respond.
      */
-    uint8_t _instanceID;
+    std::optional<uint8_t> _instanceID;
 
     /**
      * @brief The PLDM command file descriptor for the current command
@@ -155,6 +190,21 @@
      * @brief The command timeout value
      */
     const std::chrono::milliseconds _receiveTimeout{10000};
+
+    /**
+     * @brief The D-Bus connection needed for the async method call.
+     */
+    sd_bus* _bus = nullptr;
+
+    /**
+     * @brief The ID of the PEL to notify the host of.
+     */
+    uint32_t _pelID = 0;
+
+    /**
+     * @brief The size of the PEL to notify the host of.
+     */
+    uint32_t _pelSize = 0;
 };
 
 } // namespace openpower::pels