diff --git a/src/DebugServer/Gdb/GdbRspDebugServer.hpp b/src/DebugServer/Gdb/GdbRspDebugServer.hpp
index 6b7251f8..26671189 100644
--- a/src/DebugServer/Gdb/GdbRspDebugServer.hpp
+++ b/src/DebugServer/Gdb/GdbRspDebugServer.hpp
@@ -114,9 +114,7 @@ namespace Bloom::DebugServer::Gdb
          *
          * See documentation in src/DebugServer/Gdb/README.md for more on how GDB commands are processed.
          */
-        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole(
-            this->eventListener
-        );
+        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole();
 
         /**
          * Listening socket address
diff --git a/src/Insight/Insight.hpp b/src/Insight/Insight.hpp
index 61964000..761065bf 100644
--- a/src/Insight/Insight.hpp
+++ b/src/Insight/Insight.hpp
@@ -78,9 +78,7 @@ namespace Bloom
             this->insightProjectSettings
         );
 
-        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole(
-            this->eventListener
-        );
+        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole();
 
         /**
          * Insight consists of two threads - the main thread where the main Qt event loop runs (for the GUI), and
diff --git a/src/Insight/InsightWorker/InsightWorker.hpp b/src/Insight/InsightWorker/InsightWorker.hpp
index ca736df8..f508b3d9 100644
--- a/src/Insight/InsightWorker/InsightWorker.hpp
+++ b/src/Insight/InsightWorker/InsightWorker.hpp
@@ -46,9 +46,7 @@ namespace Bloom
     private:
         EventListenerPointer eventListener = std::make_shared<EventListener>("InsightWorkerEventListener");
 
-        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole(
-            *(this->eventListener)
-        );
+        TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole();
 
         Targets::TargetState lastTargetState = Targets::TargetState::UNKNOWN;
 
diff --git a/src/TargetController/TargetControllerConsole.cpp b/src/TargetController/TargetControllerConsole.cpp
index 7e5a0d9b..32999cc9 100644
--- a/src/TargetController/TargetControllerConsole.cpp
+++ b/src/TargetController/TargetControllerConsole.cpp
@@ -1,7 +1,5 @@
 #include "TargetControllerConsole.hpp"
 
-#include "src/EventManager/Events/Events.hpp"
-
 #include "TargetControllerComponent.hpp"
 
 // Commands
@@ -28,7 +26,6 @@
 namespace Bloom::TargetController
 {
     using namespace Bloom::Targets;
-    using namespace Bloom::Events;
     using namespace Bloom::Exceptions;
 
     using Commands::GetTargetDescriptor;
@@ -49,10 +46,6 @@ namespace Bloom::TargetController
     using Commands::GetTargetStackPointer;
     using Commands::GetTargetProgramCounter;
 
-    TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
-        : eventListener(eventListener)
-    {}
-
     TargetControllerState TargetControllerConsole::getTargetControllerState() {
         return TargetControllerComponent::getState();
     }
diff --git a/src/TargetController/TargetControllerConsole.hpp b/src/TargetController/TargetControllerConsole.hpp
index e5c8b49e..7ee19e20 100644
--- a/src/TargetController/TargetControllerConsole.hpp
+++ b/src/TargetController/TargetControllerConsole.hpp
@@ -6,9 +6,6 @@
 #include "CommandManager.hpp"
 #include "TargetControllerState.hpp"
 
-#include "src/EventManager/EventListener.hpp"
-#include "src/EventManager/EventManager.hpp"
-
 #include "src/Targets/TargetState.hpp"
 #include "src/Targets/TargetRegister.hpp"
 #include "src/Targets/TargetMemory.hpp"
@@ -26,7 +23,7 @@ namespace Bloom::TargetController
     class TargetControllerConsole
     {
     public:
-        TargetControllerConsole(EventListener& eventListener);
+        TargetControllerConsole() = default;
 
         void setDefaultTimeout(std::chrono::milliseconds timeout) {
             this->defaultTimeout = timeout;
@@ -187,73 +184,7 @@ namespace Bloom::TargetController
 
     private:
         CommandManager commandManager = CommandManager();
-        EventListener& eventListener;
 
         std::chrono::milliseconds defaultTimeout = std::chrono::milliseconds(20000);
-
-        /**
-         * Triggers an event for the TargetController and waits for a response.
-         *
-         * To use this method, the triggered event must define a 'TargetControllerResponseType' alias, which should
-         * specify the type of response expected from the TargetController.
-         * For an example of this, see the Events::ExtractTargetDescriptor class.
-         *
-         * If the TargetController fails to respond within the given time specified by the timeout argument, or it
-         * responds with an instance of Events::TargetControllerErrorOccurred, this function will throw an exception.
-         *
-         * @tparam TriggerEventType
-         *
-         * @param event
-         *  Event to trigger.
-         *
-         * @param timeout
-         *  The time, in milliseconds, to wait for the TargetController to respond to the event. If this is not
-         *  supplied, this->defaultTimeout will be used.
-         *
-         * @return
-         */
-        template<class TriggerEventType>
-        auto triggerTargetControllerEventAndWaitForResponse(
-            const Events::SharedEventPointerNonConst<TriggerEventType> event,
-            std::optional<std::chrono::milliseconds> timeout = {}
-        ) {
-            using Bloom::Events::SharedEventPointer;
-            using Bloom::Events::TargetControllerErrorOccurred;
-
-            using ResponseEventType = typename TriggerEventType::TargetControllerResponseType;
-
-            bool deRegisterEventType = false;
-
-            if (!this->eventListener.isEventTypeRegistered<ResponseEventType>()) {
-                this->eventListener.registerEventType<ResponseEventType>();
-                deRegisterEventType = true;
-            }
-
-            EventManager::triggerEvent(event);
-
-            auto responseEvent = this->eventListener.waitForEvent<
-                ResponseEventType,
-                TargetControllerErrorOccurred
-            >(timeout.value_or(this->defaultTimeout), event->id);
-
-            if (deRegisterEventType) {
-                this->eventListener.deRegisterEventType<ResponseEventType>();
-            }
-
-            if (!responseEvent.has_value()) {
-                throw Bloom::Exceptions::Exception("Timed out waiting for response from TargetController.");
-            }
-
-            if (!std::holds_alternative<SharedEventPointer<ResponseEventType>>(responseEvent.value())) {
-                if (std::holds_alternative<SharedEventPointer<TargetControllerErrorOccurred>>(responseEvent.value())) {
-                    auto& tcErrorEvent = std::get<SharedEventPointer<TargetControllerErrorOccurred>>(responseEvent.value());
-                    throw Bloom::Exceptions::Exception(tcErrorEvent->errorMessage);
-                }
-
-                throw Bloom::Exceptions::Exception("Unexpected response from TargetController");
-            }
-
-            return std::get<SharedEventPointer<ResponseEventType>>(responseEvent.value());
-        }
     };
 }