diff --git a/.github/workflows/test.workflow.yml b/.github/workflows/test.workflow.yml
index 550123a232..3465fa3c82 100644
--- a/.github/workflows/test.workflow.yml
+++ b/.github/workflows/test.workflow.yml
@@ -54,8 +54,8 @@ jobs:
     uses: ./.github/workflows/test_child.yml
     with:
       flavor: "vanilla"
-      luxonis_os_versions_to_test: "['1.14.1', '1.15.0', '1.18.3']"
-      luxonis_os_versions_to_test_rgb: "['1.18.3']"
+      luxonis_os_versions_to_test: "['1.14.1', '1.15.0', '1.18.3', 'usb-testing-build']"
+      luxonis_os_versions_to_test_rgb: "['1.18.3', 'usb-testing-build']"
     secrets:
       CONTAINER_REGISTRY: ${{ secrets.CONTAINER_REGISTRY }}
       HIL_PAT_TOKEN: ${{ secrets.HIL_PAT_TOKEN }}
diff --git a/cmake/Depthai/DepthaiDeviceRVC4Config.cmake b/cmake/Depthai/DepthaiDeviceRVC4Config.cmake
index 1e26e9d084..893a6463d2 100644
--- a/cmake/Depthai/DepthaiDeviceRVC4Config.cmake
+++ b/cmake/Depthai/DepthaiDeviceRVC4Config.cmake
@@ -3,4 +3,5 @@
 set(DEPTHAI_DEVICE_RVC4_MATURITY "snapshot")
 
 # "version if applicable"
-set(DEPTHAI_DEVICE_RVC4_VERSION "0.0.1+cd0fc231d8c860acf11ab424109d7e42500626ae")
+# set(DEPTHAI_DEVICE_RVC4_VERSION "0.0.1+93f7b75a885aa32f44c5e9f53b74470c49d2b1af")
+set(DEPTHAI_DEVICE_RVC4_VERSION "0.0.1+aa774579d184a6d4ad93cc7af357e0a5d772036f")
\ No newline at end of file
diff --git a/cmake/depthaiDependencies.cmake b/cmake/depthaiDependencies.cmake
index f50ff81912..08752ec36c 100644
--- a/cmake/depthaiDependencies.cmake
+++ b/cmake/depthaiDependencies.cmake
@@ -177,7 +177,7 @@ else()
     FetchContent_Declare(
         XLink
         GIT_REPOSITORY https://github.com/luxonis/XLink.git
-        GIT_TAG        7958fece3f7b303b1a2038ea7e78f53405f89843
+        GIT_TAG        e56ec8ad10381ef58cde3be430ebf77a470623d2
     )
 
     FetchContent_MakeAvailable(
diff --git a/examples/cpp/Camera/camera_max_resolution.cpp b/examples/cpp/Camera/camera_max_resolution.cpp
index 5be761ebbf..86eb996f82 100644
--- a/examples/cpp/Camera/camera_max_resolution.cpp
+++ b/examples/cpp/Camera/camera_max_resolution.cpp
@@ -31,4 +31,4 @@ int main() {
     }
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/examples/cpp/Camera/camera_output.cpp b/examples/cpp/Camera/camera_output.cpp
index cdaeac32d9..e12e8adb77 100644
--- a/examples/cpp/Camera/camera_output.cpp
+++ b/examples/cpp/Camera/camera_output.cpp
@@ -30,4 +30,4 @@ int main() {
     }
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/include/depthai/device/DeviceGate.hpp b/include/depthai/device/DeviceGate.hpp
index 7e75c97b04..019892ecc7 100644
--- a/include/depthai/device/DeviceGate.hpp
+++ b/include/depthai/device/DeviceGate.hpp
@@ -14,6 +14,7 @@
 #include "depthai/device/Version.hpp"
 #include "depthai/utility/Pimpl.hpp"
 #include "depthai/xlink/XLinkConnection.hpp"
+#include "depthai/xlink/XLinkStream.hpp"
 namespace dai {
 
 /**
@@ -55,6 +56,64 @@ class DeviceGate {
 
    private:
     // private
+    class GateImpl {
+       public:
+        virtual ~GateImpl() = default;
+        virtual bool isOkay() = 0;
+        virtual bool createSession(std::string version, bool exclusive, XLinkPlatform_t platform, std::string& sessionId, std::atomic_bool& sessionCreated) = 0;
+        virtual bool startSession(std::string sessionId) = 0;
+        virtual bool stopSession(std::string sessionId) = 0;
+        virtual bool deleteSession(std::string sessionId) = 0;
+        virtual bool destroySession(std::string sessionId) = 0;
+        virtual SessionState getState(std::string sessionId) = 0;
+        virtual Version getVersion() = 0;
+        virtual VersionInfo getAllVersion() = 0;
+        virtual std::optional<std::vector<uint8_t>> getFile(const std::string& fileUrl, std::string& filename) = 0;
+    };
+
+    class USBImpl : public GateImpl {
+       public:
+        USBImpl(DeviceInfo deviceInfo, int timeout);
+        ~USBImpl() = default;
+        bool isOkay() override;
+        bool createSession(std::string version, bool exclusive, XLinkPlatform_t platform, std::string& sessionId, std::atomic_bool& sessionCreated) override;
+        bool startSession(std::string sessionId) override;
+        bool stopSession(std::string sessionId) override;
+        bool deleteSession(std::string sessionId) override;
+        bool destroySession(std::string sessionId) override;
+        SessionState getState(std::string sessionId) override;
+        Version getVersion() override;
+        VersionInfo getAllVersion() override;
+        std::optional<std::vector<uint8_t>> getFile(const std::string& fileUrl, std::string& filename) override;
+
+       private:
+	DeviceInfo deviceInfo;
+        int timeout;
+    };
+
+    class HTTPImpl : public GateImpl {
+       public:
+        HTTPImpl(DeviceInfo deviceInfo);
+        ~HTTPImpl() = default;
+        bool isOkay() override;
+        bool createSession(std::string version, bool exclusive, XLinkPlatform_t platform, std::string& sessionId, std::atomic_bool& sessionCreated) override;
+        bool startSession(std::string sessionId) override;
+        bool stopSession(std::string sessionId) override;
+        bool deleteSession(std::string sessionId) override;
+        bool destroySession(std::string sessionId) override;
+        SessionState getState(std::string sessionId) override;
+        Version getVersion() override;
+        VersionInfo getAllVersion() override;
+        std::optional<std::vector<uint8_t>> getFile(const std::string& fileUrl, std::string& filename) override;
+
+       private:
+        // pimpl
+        class Impl;
+        Pimpl<Impl> pimpl;
+    };
+
+    std::shared_ptr<GateImpl> impl;
+
     DeviceInfo deviceInfo;
 
     std::thread stateMonitoringThread;
@@ -65,10 +124,9 @@ class DeviceGate {
     std::atomic_bool sessionCreated{false};
 
     XLinkPlatform_t platform;
+    std::shared_ptr<XLinkConnection> gateConnection;
+    std::shared_ptr<XLinkStream> gateStream;
     std::string version;
-    // pimpl
-    class Impl;
-    Pimpl<Impl> pimpl;
 
     std::string sessionId;
 };
diff --git a/include/depthai/pipeline/MessageQueue.hpp b/include/depthai/pipeline/MessageQueue.hpp
index e7667e6238..4538668dec 100644
--- a/include/depthai/pipeline/MessageQueue.hpp
+++ b/include/depthai/pipeline/MessageQueue.hpp
@@ -44,13 +44,13 @@ class MessageQueue : public std::enable_shared_from_this<MessageQueue> {
     explicit MessageQueue(std::string name, unsigned int maxSize = 16, bool blocking = true);
 
     MessageQueue(const MessageQueue& c)
-        : enable_shared_from_this(c), queue(c.queue), name(c.name), callbacks(c.callbacks), uniqueCallbackId(c.uniqueCallbackId){};
+        : enable_shared_from_this(c), queue(c.queue), name(c.name), callbacks(c.callbacks), uniqueCallbackId(c.uniqueCallbackId) {};
     MessageQueue(MessageQueue&& m) noexcept
         : enable_shared_from_this(m),
           queue(std::move(m.queue)),
           name(std::move(m.name)),
           callbacks(std::move(m.callbacks)),
-          uniqueCallbackId(m.uniqueCallbackId){};
+          uniqueCallbackId(m.uniqueCallbackId) {};
 
     MessageQueue& operator=(const MessageQueue& c) {
         queue = c.queue;
diff --git a/include/depthai/pipeline/Node.hpp b/include/depthai/pipeline/Node.hpp
index cd6ef073ef..6e5993fa79 100644
--- a/include/depthai/pipeline/Node.hpp
+++ b/include/depthai/pipeline/Node.hpp
@@ -65,7 +65,9 @@ class Node : public std::enable_shared_from_this<Node> {
     static constexpr auto DEFAULT_NAME = "";
 #define DEFAULT_TYPES                  \
     {                                  \
-        { DatatypeEnum::Buffer, true } \
+        {                              \
+            DatatypeEnum::Buffer, true \
+        }                              \
     }
     static constexpr auto DEFAULT_BLOCKING = true;
     static constexpr auto DEFAULT_QUEUE_SIZE = 3;
diff --git a/include/depthai/utility/ImageManipImpl.hpp b/include/depthai/utility/ImageManipImpl.hpp
index 505e0e09c1..184f361a6b 100644
--- a/include/depthai/utility/ImageManipImpl.hpp
+++ b/include/depthai/utility/ImageManipImpl.hpp
@@ -457,8 +457,7 @@ class ColorChange {
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 class ImageManipOperations {
     static_assert(std::is_base_of<Warp<ImageManipBuffer, ImageManipData>, WarpBackend<ImageManipBuffer, ImageManipData>>::value,
                   "WarpBackend must be derived from Warp");
@@ -2697,8 +2696,7 @@ inline dai::ImgFrame::Type getValidType(dai::ImgFrame::Type type) {
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>& ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::build(
     const ImageManipOpsBase<Container>& newBase, ImgFrame::Type outType, FrameSpecs srcFrameSpecs, ImgFrame::Type inFrameType) {
     const auto newCfgStr = newBase.str();
@@ -2806,8 +2804,7 @@ ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>& ImageManipO
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>& ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::buildUndistort(
     bool enable,
     const std::array<float, 9>& cameraMatrix,
@@ -2826,8 +2823,7 @@ size_t getFrameSize(const ImgFrame::Type type, const FrameSpecs& specs);
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 bool ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::apply(const std::shared_ptr<ImageManipData> src,
                                                                                 std::shared_ptr<ImageManipData> dst) {
     size_t requiredSize = getFrameSize(inType, srcSpecs);
@@ -2879,24 +2875,21 @@ bool ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::apply(
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputWidth() const {
     return base.outputWidth;
 }
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputHeight() const {
     return base.outputHeight;
 }
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputStride(uint8_t plane) const {
     if(mode == 0) return plane == 0 ? srcSpecs.p1Stride : (plane == 1 ? srcSpecs.p2Stride : (plane == 2 ? srcSpecs.p3Stride : 0));
     auto specs = getOutputFrameSpecs(outputFrameType);
@@ -2912,8 +2905,7 @@ size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getO
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputPlaneSize(uint8_t plane) const {
     if(mode == 0) return 0;
     size_t size = 0;
@@ -2978,8 +2970,7 @@ size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getO
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputSize() const {
     if(mode == 0) return 0;
     size_t size = 0;
@@ -3034,8 +3025,7 @@ size_t ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getO
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 FrameSpecs ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getOutputFrameSpecs(ImgFrame::Type type) const {
     if(mode == 0)
         return srcSpecs;
@@ -3045,8 +3035,7 @@ FrameSpecs ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 std::vector<RotatedRect> ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getSrcCrops() const {
     std::vector<RotatedRect> crops;
     for(const auto& corners : srcCorners) {
@@ -3058,16 +3047,14 @@ std::vector<RotatedRect> ImageManipOperations<ImageManipBuffer, ImageManipData,
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 std::array<std::array<float, 3>, 3> ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::getMatrix() const {
     return matrix;
 }
 
 template <template <typename T> typename ImageManipBuffer,
           typename ImageManipData,
-          template <template <typename T> typename Buf, typename Dat>
-          typename WarpBackend>
+          template <template <typename T> typename Buf, typename Dat> typename WarpBackend>
 std::string ImageManipOperations<ImageManipBuffer, ImageManipData, WarpBackend>::toString() const {
     std::stringstream cStr;
     cStr << getConfigString(base);
diff --git a/include/depthai/utility/LockingQueue.hpp b/include/depthai/utility/LockingQueue.hpp
index f4a8593966..f6948e0a06 100644
--- a/include/depthai/utility/LockingQueue.hpp
+++ b/include/depthai/utility/LockingQueue.hpp
@@ -26,8 +26,8 @@ class LockingQueue {
         this->maxSize = maxSize;
         this->blocking = blocking;
     }
-    LockingQueue(const LockingQueue& obj) : maxSize(obj.maxSize), blocking(obj.blocking), queue(obj.queue), destructed(obj.destructed){};
-    LockingQueue(LockingQueue&& obj) noexcept : maxSize(obj.maxSize), blocking(obj.blocking), queue(std::move(obj.queue)), destructed(obj.destructed){};
+    LockingQueue(const LockingQueue& obj) : maxSize(obj.maxSize), blocking(obj.blocking), queue(obj.queue), destructed(obj.destructed) {};
+    LockingQueue(LockingQueue&& obj) noexcept : maxSize(obj.maxSize), blocking(obj.blocking), queue(std::move(obj.queue)), destructed(obj.destructed) {};
     LockingQueue& operator=(const LockingQueue& obj) {
         maxSize = obj.maxSize;
         blocking = obj.blocking;
diff --git a/include/depthai/utility/MemoryWrappers.hpp b/include/depthai/utility/MemoryWrappers.hpp
index cc0204904c..9a7ff64061 100644
--- a/include/depthai/utility/MemoryWrappers.hpp
+++ b/include/depthai/utility/MemoryWrappers.hpp
@@ -2,7 +2,7 @@
 
 // memfd_create wrapper for glibc < 2.27
 #if defined(__unix__) && !defined(__APPLE__)
-    #if(__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 27)
+    #if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 27)
 
 int memfd_create(const char* name, unsigned int flags);
 
diff --git a/include/depthai/utility/NlohmannJsonCompat.hpp b/include/depthai/utility/NlohmannJsonCompat.hpp
index c138bea8d4..1d86416f5d 100644
--- a/include/depthai/utility/NlohmannJsonCompat.hpp
+++ b/include/depthai/utility/NlohmannJsonCompat.hpp
@@ -3,8 +3,8 @@
 #include <nlohmann/json.hpp>
 
 // Check version of nlohmann json
-#if(defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR))
-    #if((NLOHMANN_JSON_VERSION_MAJOR < 3) || ((NLOHMANN_JSON_VERSION_MAJOR == 3) && (NLOHMANN_JSON_VERSION_MINOR < 6)))
+#if (defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR))
+    #if ((NLOHMANN_JSON_VERSION_MAJOR < 3) || ((NLOHMANN_JSON_VERSION_MAJOR == 3) && (NLOHMANN_JSON_VERSION_MINOR < 6)))
 static_assert(0, "DepthAI requires nlohmann library version 3.6.0 or higher");
     #else
         // Set up compat macros for nlohmann json (independent of version)
diff --git a/src/device/DeviceGate.cpp b/src/device/DeviceGate.cpp
index 7698736e52..275d81e0a7 100644
--- a/src/device/DeviceGate.cpp
+++ b/src/device/DeviceGate.cpp
@@ -1,5 +1,6 @@
 #include "device/DeviceGate.hpp"
 
+#include <XLink/XLink.h>
 #include <XLink/XLinkPublicDefines.h>
 
 // std
@@ -26,8 +27,29 @@ namespace dai {
 const std::string API_ROOT{"/api/v1"};
 const auto sessionsEndpoint = API_ROOT + "/sessions";
 const int DEFAULT_PORT{11492};
+const int gateTimeout = 2000;
+
+enum USBRequestID_t {
+    RESPONSE_OK,
+    RESPONSE_ERROR,
+    CREATE_SESSION,
+    START_SESSION,
+    UPLOAD_FWP,
+    STOP_SESSION,
+    DESTROY_SESSION,
+    DELETE_SESSION,
+    IS_OKAY,
+    GET_VERSION,
+    GET_STATE,
+    GET_FILE,
+};
+
+struct USBRequest_t {
+    uint32_t RequestNum;
+    uint32_t RequestSize;
+};
 
-class DeviceGate::Impl {
+class DeviceGate::HTTPImpl::Impl {
    public:
     Impl() = default;
 
@@ -52,29 +74,106 @@ DeviceGate::DeviceGate(const DeviceInfo& deviceInfo) : deviceInfo(deviceInfo) {
     } else {
         throw std::runtime_error("Unknown platform");  // Should never happen
     }
+
+    if(deviceInfo.protocol == X_LINK_USB_EP) {
+        impl = std::make_shared<USBImpl>(deviceInfo, gateTimeout);
+    } else {
+        impl = std::make_shared<HTTPImpl>(deviceInfo);
+    }
+}
+
+DeviceGate::HTTPImpl::HTTPImpl(DeviceInfo deviceInfo) {
     // Discover and connect
     pimpl->cli = std::make_unique<httplib::Client>(deviceInfo.name, DEFAULT_PORT);
     pimpl->cli->set_read_timeout(60);  // 60 seconds timeout to allow for compressing the crash dumps without async
     // pimpl->cli->set_connection_timeout(2);
 }
 
+DeviceGate::USBImpl::USBImpl(DeviceInfo deviceInfo, int timeout) : deviceInfo(deviceInfo), timeout(timeout) {}
+
 bool DeviceGate::isOkay() {
-    if(auto res = pimpl->cli->Get("/api/v1/status")) {
-        return nlohmann::json::parse(res->body)["status"].get<bool>();
+    return impl->isOkay();
+}
+
+bool DeviceGate::HTTPImpl::isOkay() {
+    auto res = pimpl->cli->Get("/api/v1/status");
+    return nlohmann::json::parse(res->body)["status"].get<bool>();
+}
+
+bool DeviceGate::USBImpl::isOkay() {
+    USBRequest_t request;
+    request.RequestNum = IS_OKAY;
+    request.RequestSize = 0;
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
     }
-    return false;
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+
+    if(request.RequestNum == RESPONSE_ERROR) {
+        return false;
+    }
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return {};
+    }
+    respBuffer[request.RequestSize] = '\0';
+
+    bool result = nlohmann::json::parse(respBuffer)["status"].get<bool>();
+
+    return result;
 }
 
 Version DeviceGate::getVersion() {
+    return impl->getVersion();
+}
+
+Version DeviceGate::HTTPImpl::getVersion() {
     httplib::Result res = pimpl->cli->Get("/api/v1/version");
     if(res && res->status == 200) {
         auto versionStr = nlohmann::json::parse(res->body)["version_gate"].get<std::string>();
         return Version{versionStr};
+    } else {
+        return Version{0, 0, 0};
     }
-    return Version{0, 0, 0};
+}
+
+Version DeviceGate::USBImpl::getVersion() {
+    USBRequest_t request;
+    request.RequestNum = GET_VERSION;
+    request.RequestSize = 0;
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return {0, 0, 0};
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return {0, 0, 0};
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
+        return Version{0, 0, 0};
+    }
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return {0, 0, 0};
+    }
+    respBuffer[request.RequestSize] = '\0';
+
+    auto result = nlohmann::json::parse(respBuffer)["version_gate"].get<std::string>();
+
+    return Version{result};
 }
 
 DeviceGate::VersionInfo DeviceGate::getAllVersion() {
+    return impl->getAllVersion();
+}
+
+DeviceGate::VersionInfo DeviceGate::HTTPImpl::getAllVersion() {
     httplib::Result res = pimpl->cli->Get("/api/v1/version");
     if(res && res->status == 200) {
         auto result = nlohmann::json::parse(res->body);
@@ -84,10 +183,45 @@ DeviceGate::VersionInfo DeviceGate::getAllVersion() {
         info.os = result.value("version_os", "");
         return info;
     }
+
     return {};
 }
 
+DeviceGate::VersionInfo DeviceGate::USBImpl::getAllVersion() {
+    USBRequest_t request;
+    request.RequestNum = GET_VERSION;
+    request.RequestSize = 0;
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return {};
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return {};
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
+        return {};
+    }
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return {};
+    }
+    respBuffer[request.RequestSize] = '\0';
+    auto result = nlohmann::json::parse(respBuffer);
+
+    VersionInfo info;
+    info.gate = result.value("version_gate", "");
+    info.os = result.value("version_os", "");
+    return info;
+}
+
 bool DeviceGate::createSession(bool exclusive) {
+    return impl->createSession(version, exclusive, platform, sessionId, sessionCreated);
+}
+
+bool DeviceGate::HTTPImpl::createSession(
+    std::string version, bool exclusive, XLinkPlatform_t platform, std::string& sessionId, std::atomic_bool& sessionCreated) {
     nlohmann::json createSessionBody = {{"name", "depthai_session"},
                                         // {"fwp_checksum", fwpChecksum},
                                         {"fwp_version", version},
@@ -96,73 +230,163 @@ bool DeviceGate::createSession(bool exclusive) {
 
     spdlog::debug("DeviceGate createSession: {}", createSessionBody.dump());
 
-    if(auto res = pimpl->cli->Post(sessionsEndpoint.c_str(), createSessionBody.dump(), "application/json")) {
-        // Parse response
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate createSession not successful - status: {}, error: {}", res->status, res->body);
-            return false;
+    auto res = pimpl->cli->Post(sessionsEndpoint.c_str(), createSessionBody.dump(), "application/json");
+    // Parse response
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate createSession not successful - status: {}, error: {}", res->status, res->body);
+        return false;
+    }
+    auto resp = nlohmann::json::parse(res->body);
+    spdlog::debug("DeviceGate createSession response: {}", resp.dump());
+
+    // Retrieve sessionId
+    sessionId = resp["id"];
+    bool fwpExists = resp["fwp_exists"].get<bool>();
+
+    if(!fwpExists) {
+        std::vector<uint8_t> package;
+        std::string path;
+        if(!path.empty()) {
+            std::ifstream fwStream(path, std::ios::binary);
+            if(!fwStream.is_open()) throw std::runtime_error(fmt::format("Cannot flash bootloader, binary at path: {} doesn't exist", path));
+            package = std::vector<std::uint8_t>(std::istreambuf_iterator<char>(fwStream), {});
+        } else {
+            package = platform == X_LINK_RVC3 ? Resources::getInstance().getDeviceRVC3Fwp() : Resources::getInstance().getDeviceRVC4Fwp();
         }
-        auto resp = nlohmann::json::parse(res->body);
-        spdlog::debug("DeviceGate createSession response: {}", resp.dump());
-
-        // Retrieve sessionId
-        sessionId = resp["id"];
-        bool fwpExists = resp["fwp_exists"].get<bool>();
-
-        if(!fwpExists) {
-            std::vector<uint8_t> package;
-            std::string path;
-            if(!path.empty()) {
-                std::ifstream fwStream(path, std::ios::binary);
-                if(!fwStream.is_open()) throw std::runtime_error(fmt::format("Cannot flash bootloader, binary at path: {} doesn't exist", path));
-                package = std::vector<std::uint8_t>(std::istreambuf_iterator<char>(fwStream), {});
-            } else {
-                package = platform == X_LINK_RVC3 ? Resources::getInstance().getDeviceRVC3Fwp() : Resources::getInstance().getDeviceRVC4Fwp();
-            }
-
-            // TODO(themarpe) - Inefficient
-            httplib::MultipartFormDataItems items = {
-                {"file", std::string(package.begin(), package.end()), "depthai-device-kb-fwp.tar.xz", "application/octet-stream"},
-            };
-
-            std::string url = fmt::format("{}/{}/fwp", sessionsEndpoint, sessionId);
-            if(auto res = pimpl->cli->Post(url.c_str(), items)) {
-                if(res.value().status == 200) {
-                    spdlog::debug("DeviceGate upload fwp successful");
-                    sessionCreated = true;
-                    return true;
-                } else {
-                    spdlog::warn("DeviceGate upload fwp not successful - status: {}, error: {}", res->status, res->body);
-                    return false;
-                }
 
+        // TODO(themarpe) - Inefficient
+        httplib::MultipartFormDataItems items = {
+            {"file", std::string(package.begin(), package.end()), "depthai-device-kb-fwp.tar.xz", "application/octet-stream"},
+        };
+
+        std::string url = fmt::format("{}/{}/fwp", sessionsEndpoint, sessionId);
+        if(auto res = pimpl->cli->Post(url.c_str(), items)) {
+            if(res.value().status == 200) {
+                spdlog::debug("DeviceGate upload fwp successful");
+                sessionCreated = true;
+                return true;
             } else {
-                spdlog::warn("DeviceGate upload fwp not successful - got no response");
+                spdlog::warn("DeviceGate upload fwp not successful - status: {}, error: {}", res->status, res->body);
                 return false;
             }
+
+        } else {
+            spdlog::warn("DeviceGate upload fwp not successful - got no response");
+            return false;
         }
-        sessionCreated = true;
-        return true;
-    } else {
+    }
+    sessionCreated = true;
+    return true;
+}
+
+bool DeviceGate::USBImpl::createSession(
+    std::string version, bool exclusive, XLinkPlatform_t platform, std::string& sessionId, std::atomic_bool& sessionCreated) {
+    nlohmann::json createSessionBody = {{"name", "depthai_session"},
+                                        // {"fwp_checksum", fwpChecksum},
+                                        {"fwp_version", version},
+                                        {"library_version", build::VERSION},
+                                        {"protected", exclusive}};
+
+    spdlog::debug("DeviceGate createSession: {}", createSessionBody.dump());
+    USBRequest_t request;
+    request.RequestNum = CREATE_SESSION;
+    request.RequestSize = createSessionBody.dump().size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)createSessionBody.dump().c_str(), createSessionBody.dump().size(), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
         spdlog::warn("DeviceGate createSession not successful - got no response");
+        return false;
+    }
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    respBuffer[request.RequestSize] = '\0';
+    auto resp = nlohmann::json::parse(respBuffer);
+    spdlog::debug("DeviceGate createSession response: {}", resp.dump());
+
+    // Retrieve sessionId
+    sessionId = resp["id"];
+    bool fwpExists = resp["fwp_exists"].get<bool>();
+
+    if(!fwpExists) {
+        std::vector<uint8_t> package;
+        std::string path;
+        if(!path.empty()) {
+            std::ifstream fwStream(path, std::ios::binary);
+            if(!fwStream.is_open()) throw std::runtime_error(fmt::format("Cannot flash bootloader, binary at path: {} doesn't exist", path));
+            package = std::vector<std::uint8_t>(std::istreambuf_iterator<char>(fwStream), {});
+        } else {
+            package = platform == X_LINK_RVC3 ? Resources::getInstance().getDeviceRVC3Fwp() : Resources::getInstance().getDeviceRVC4Fwp();
+        }
+
+        nlohmann::json uploadFwpBody = {{"sessionId", sessionId}, {"file", package}};
+        request.RequestNum = UPLOAD_FWP;
+        request.RequestSize = uploadFwpBody.dump().size();
+        if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+            return false;
+        }
+        if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)uploadFwpBody.dump().c_str(), uploadFwpBody.dump().size(), timeout) == X_LINK_ERROR) {
+            return false;
+        }
+
+        if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+            return false;
+        }
+        if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::warn("DeviceGate upload fwp not successful - got no response");
+            return false;
+        }
     }
-    return false;
+    sessionCreated = true;
+    return true;
 }
 
 bool DeviceGate::startSession() {
+    return impl->startSession(sessionId);
+}
+
+bool DeviceGate::HTTPImpl::startSession(std::string sessionId) {
     std::string url = fmt::format("{}/{}/start", sessionsEndpoint, sessionId);
-    if(auto res = pimpl->cli->Post(url.c_str())) {
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate start fwp not successful - status: {}, error: {}", res->status, res->body);
-            return false;
-        }
-        spdlog::debug("DeviceGate start fwp successful");
-        return true;
-    } else {
-        spdlog::debug("DeviceGate start fwp not successful - got no response");
+    auto res = pimpl->cli->Post(url.c_str());
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate start fwp not successful - status: {}, error: {}", res->status, res->body);
+        return false;
     }
+    spdlog::debug("DeviceGate start fwp successful");
+    return true;
+}
 
-    return false;
+bool DeviceGate::USBImpl::startSession(std::string sessionId) {
+    USBRequest_t request;
+    request.RequestNum = START_SESSION;
+    request.RequestSize = sessionId.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)sessionId.c_str(), sessionId.size(), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
+        spdlog::debug("DeviceGate start fwp not successful - got no response");
+        return false;
+    }
+    spdlog::debug("DeviceGate start fwp successful");
+    return true;
 }
 
 bool DeviceGate::stopSession() {
@@ -176,22 +400,40 @@ bool DeviceGate::stopSession() {
         spdlog::debug("No need to stop a session that wasn't created.");
         return true;
     }
+    return impl->stopSession(sessionId);
+}
 
-    const auto sessionsEndpoint = API_ROOT + "/sessions";
-
+bool DeviceGate::HTTPImpl::stopSession(std::string sessionId) {
     std::string url = fmt::format("{}/{}/stop", sessionsEndpoint, sessionId);
-    if(auto res = pimpl->cli->Post(url.c_str())) {
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate stopSession not successful - status: {}, error: {}", res->status, res->body);
-            return false;
-        }
-        spdlog::debug("DeviceGate stopSession successful");
-        return true;
-    } else {
-        spdlog::error("DeviceGate stopSession not successful - got no response");
+    auto res = pimpl->cli->Post(url.c_str());
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate stopSession not successful - status: {}, error: {}", res->status, res->body);
+        return false;
+    }
+    spdlog::debug("DeviceGate stopSession successful");
+    return true;
+}
+
+bool DeviceGate::USBImpl::stopSession(std::string sessionId) {
+    USBRequest_t request;
+    request.RequestNum = STOP_SESSION;
+    request.RequestSize = sessionId.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)sessionId.c_str(), sessionId.size(), timeout) == X_LINK_ERROR) {
+        return false;
     }
 
-    return false;
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
+        spdlog::error("DeviceGate stopSession not successful - got no response");
+        return false;
+    }
+    spdlog::debug("DeviceGate stopSession successful");
+    return true;
 }
 
 bool DeviceGate::destroySession() {
@@ -204,19 +446,40 @@ bool DeviceGate::destroySession() {
         spdlog::debug("No need to destroy a session that wasn't created.");
         return true;
     }
+    return impl->destroySession(sessionId);
+}
 
+bool DeviceGate::HTTPImpl::destroySession(std::string sessionId) {
     std::string url = fmt::format("{}/{}/destroy", sessionsEndpoint, sessionId);
-    if(auto res = pimpl->cli->Post(url.c_str())) {
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate destroySession not successful - status: {}, error: {}", res->status, res->body);
-            return false;
-        }
-        spdlog::debug("DeviceGate destroySession successful");
-        return true;
-    } else {
+    auto res = pimpl->cli->Post(url.c_str());
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate destroySession not successful - status: {}, error: {}", res->status, res->body);
+        return false;
+    }
+    spdlog::debug("DeviceGate destroySession successful");
+    return true;
+}
+
+bool DeviceGate::USBImpl::destroySession(std::string sessionId) {
+    USBRequest_t request;
+    request.RequestNum = DESTROY_SESSION;
+    request.RequestSize = sessionId.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)sessionId.c_str(), sessionId.size(), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
         spdlog::error("DeviceGate destroySession not successful - got no response");
+        return false;
     }
-    return false;
+    spdlog::debug("DeviceGate destroySession successful");
+    return true;
 }
 
 bool DeviceGate::deleteSession() {
@@ -224,19 +487,40 @@ bool DeviceGate::deleteSession() {
         spdlog::debug("No need to delete a session that wasn't created.");
         return true;
     }
+    return impl->deleteSession(sessionId);
+}
 
+bool DeviceGate::HTTPImpl::deleteSession(std::string sessionId) {
     std::string url = fmt::format("{}/{}", sessionsEndpoint, sessionId);
-    if(auto res = pimpl->cli->Delete(url.c_str())) {
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate deleteSession not successful - status: {}, error: {}", res->status, res->body);
-            return false;
-        }
-        spdlog::debug("DeviceGate deleteSession successful");
-        return true;
-    } else {
+    auto res = pimpl->cli->Delete(url.c_str());
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate deleteSession not successful - status: {}, error: {}", res->status, res->body);
+        return false;
+    }
+    spdlog::debug("DeviceGate deleteSession successful");
+    return true;
+}
+
+bool DeviceGate::USBImpl::deleteSession(std::string sessionId) {
+    USBRequest_t request;
+    request.RequestNum = DELETE_SESSION;
+    request.RequestSize = sessionId.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)sessionId.c_str(), sessionId.size(), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return false;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
         spdlog::error("DeviceGate deleteSession not successful - got no response");
+        return false;
     }
-    return false;
+    spdlog::debug("DeviceGate deleteSession successful");
+    return true;
 }
 
 DeviceGate::SessionState DeviceGate::getState() {
@@ -244,58 +528,146 @@ DeviceGate::SessionState DeviceGate::getState() {
         spdlog::debug("Session not yet created - can't get the session state from gate");
         return SessionState::NOT_CREATED;
     }
+    return impl->getState(sessionId);
+}
+
+DeviceGate::SessionState DeviceGate::HTTPImpl::getState(std::string sessionId) {
     auto sessionState = SessionState::CREATED;
     std::string url = fmt::format("{}/{}", sessionsEndpoint, sessionId);
-    if(auto res = pimpl->cli->Get(url.c_str())) {
-        if(res->status != 200) {
-            spdlog::warn("DeviceGate getState not successful - status: {}, error: {}", res->status, res->body);
-            return SessionState::ERROR_STATE;
-        }
-        auto resp = nlohmann::json::parse(res->body);
-        spdlog::trace("DeviceGate getState response: {}", resp.dump());
-
-        std::string sessionStateStr = resp["state"];
-        if(sessionStateStr == "CREATED") {
-            sessionState = SessionState::CREATED;
-        } else if(sessionStateStr == "RUNNING") {
-            sessionState = SessionState::RUNNING;
-        } else if(sessionStateStr == "STOPPED") {
-            sessionState = SessionState::STOPPED;
-        } else if(sessionStateStr == "STOPPING") {
-            sessionState = SessionState::STOPPING;
-        } else if(sessionStateStr == "CRASHED") {
-            sessionState = SessionState::CRASHED;
-        } else if(sessionStateStr == "DESTROYED") {
-            sessionState = SessionState::DESTROYED;
-        } else {
-            spdlog::warn("DeviceGate getState not successful - unknown session state: {}", sessionStateStr);
-            sessionState = SessionState::ERROR_STATE;
-        }
-        return sessionState;
+
+    auto res = pimpl->cli->Get(url.c_str());
+
+    if(res->status != 200) {
+        spdlog::warn("DeviceGate getState not successful - status: {}, error: {}", res->status, res->body);
+        return SessionState::ERROR_STATE;
+    }
+
+    auto resp = nlohmann::json::parse(res->body);
+    spdlog::trace("DeviceGate getState response: {}", resp.dump());
+
+    std::string sessionStateStr = resp["state"];
+
+    if(sessionStateStr == "CREATED") {
+        sessionState = SessionState::CREATED;
+    } else if(sessionStateStr == "RUNNING") {
+        sessionState = SessionState::RUNNING;
+    } else if(sessionStateStr == "STOPPED") {
+        sessionState = SessionState::STOPPED;
+    } else if(sessionStateStr == "STOPPING") {
+        sessionState = SessionState::STOPPING;
+    } else if(sessionStateStr == "CRASHED") {
+        sessionState = SessionState::CRASHED;
+    } else if(sessionStateStr == "DESTROYED") {
+        sessionState = SessionState::DESTROYED;
     } else {
+        spdlog::warn("DeviceGate getState not successful - unknown session state: {}", sessionStateStr);
+        sessionState = SessionState::ERROR_STATE;
+    }
+
+    return sessionState;
+}
+
+DeviceGate::SessionState DeviceGate::USBImpl::getState(std::string sessionId) {
+    auto sessionState = SessionState::CREATED;
+    USBRequest_t request;
+    request.RequestNum = GET_STATE;
+    request.RequestSize = sessionId.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return SessionState::ERROR_STATE;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)sessionId.c_str(), sessionId.size(), timeout) == X_LINK_ERROR) {
+        return SessionState::ERROR_STATE;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return SessionState::ERROR_STATE;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
         spdlog::warn("DeviceGate getState not successful - got no response");
+        return SessionState::ERROR_STATE;
     }
-    return SessionState::ERROR_STATE;
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return SessionState::ERROR_STATE;
+    }
+    respBuffer[request.RequestSize] = '\0';
+    auto resp = nlohmann::json::parse(respBuffer);
+    spdlog::trace("DeviceGate getState response: {}", resp.dump());
+
+    std::string sessionStateStr = resp["state"];
+    if(sessionStateStr == "CREATED") {
+        sessionState = SessionState::CREATED;
+    } else if(sessionStateStr == "RUNNING") {
+        sessionState = SessionState::RUNNING;
+    } else if(sessionStateStr == "STOPPED") {
+        sessionState = SessionState::STOPPED;
+    } else if(sessionStateStr == "STOPPING") {
+        sessionState = SessionState::STOPPING;
+    } else if(sessionStateStr == "CRASHED") {
+        sessionState = SessionState::CRASHED;
+    } else if(sessionStateStr == "DESTROYED") {
+        sessionState = SessionState::DESTROYED;
+    } else {
+        spdlog::warn("DeviceGate getState not successful - unknown session state: {}", sessionStateStr);
+        sessionState = SessionState::ERROR_STATE;
+    }
+
+    return sessionState;
 }
 
 std::optional<std::vector<uint8_t>> DeviceGate::getFile(const std::string& fileUrl, std::string& filename) {
-    // Send a GET request to the server
-    if(auto res = pimpl->cli->Get(fileUrl.c_str())) {
-        if(res->status == 200) {
-            filename = res->get_header_value("X-Filename");
-            // Convert the response body to a vector of uint8_t
-            std::vector<uint8_t> fileData(res->body.begin(), res->body.end());
-
-            spdlog::debug("File download successful. Filename: {}", filename);
-            return fileData;
-        } else {
-            spdlog::warn("File download not successful - status: {}, error: {}", res->status, res->body);
-            return std::nullopt;
-        }
+    return impl->getFile(fileUrl, filename);
+}
+
+std::optional<std::vector<uint8_t>> DeviceGate::HTTPImpl::getFile(const std::string& fileUrl, std::string& filename) {
+    auto res = pimpl->cli->Get(fileUrl.c_str());
+    if(res->status == 200) {
+        filename = res->get_header_value("X-Filename");
+        // Convert the response body to a vector of uint8_t
+        std::vector<uint8_t> fileData(res->body.begin(), res->body.end());
+
+        spdlog::debug("File download successful. Filename: {}", filename);
+        return fileData;
     } else {
+        spdlog::warn("File download not successful - status: {}, error: {}", res->status, res->body);
+        return std::nullopt;
+    }
+}
+
+std::optional<std::vector<uint8_t>> DeviceGate::USBImpl::getFile(const std::string& fileUrl, std::string& filename) {
+    USBRequest_t request;
+    request.RequestNum = GET_FILE;
+    request.RequestSize = fileUrl.size();
+    if(XLinkGateWrite(deviceInfo.name.c_str(), &request, sizeof(USBRequest_t), timeout) == X_LINK_ERROR) {
+        return std::nullopt;
+    }
+    if(XLinkGateWrite(deviceInfo.name.c_str(), (void*)fileUrl.c_str(), fileUrl.size(), timeout) == X_LINK_ERROR) {
+        return std::nullopt;
+    }
+
+    if(XLinkGateRead(deviceInfo.name.c_str(), &request, sizeof(request), timeout) == X_LINK_ERROR) {
+        return std::nullopt;
+    }
+    if(request.RequestNum == RESPONSE_ERROR) {
         spdlog::warn("File download not successful - got no response");
         return std::nullopt;
     }
+
+    std::vector<uint8_t> respBuffer;
+    respBuffer.resize(request.RequestSize + 1);
+    if(XLinkGateRead(deviceInfo.name.c_str(), &respBuffer[0], request.RequestSize, timeout) == X_LINK_ERROR) {
+        return std::nullopt;
+    }
+    respBuffer[request.RequestSize] = '\0';
+    auto resp = nlohmann::json::parse(respBuffer);
+
+    filename = resp["filename"].get<std::string>();
+    std::vector<uint8_t> fileData(resp["data"].get<std::vector<uint8_t>>());
+
+    spdlog::debug("File download successful. Filename: {}", filename);
+    return fileData;
 }
 
 std::optional<DeviceGate::CrashDump> DeviceGate::waitForSessionEnd() {
diff --git a/src/pipeline/Node.cpp b/src/pipeline/Node.cpp
index 8f6a1ac90c..2e464c7fbd 100644
--- a/src/pipeline/Node.cpp
+++ b/src/pipeline/Node.cpp
@@ -311,7 +311,7 @@ Node::OutputMap::OutputMap(Node& parent, std::string name, Node::OutputDescripti
     }
 }
 
-Node::OutputMap::OutputMap(Node& parent, Node::OutputDescription defaultOutput, bool ref) : OutputMap(parent, "", std::move(defaultOutput), ref){};
+Node::OutputMap::OutputMap(Node& parent, Node::OutputDescription defaultOutput, bool ref) : OutputMap(parent, "", std::move(defaultOutput), ref) {};
 
 Node::Output& Node::OutputMap::operator[](const std::string& key) {
     if(count({name, key}) == 0) {
@@ -343,7 +343,7 @@ Node::InputMap::InputMap(Node& parent, std::string name, Node::InputDescription
     parent.setInputMapRefs(this);
 }
 
-Node::InputMap::InputMap(Node& parent, Node::InputDescription description) : InputMap(parent, "", std::move(description)){};
+Node::InputMap::InputMap(Node& parent, Node::InputDescription description) : InputMap(parent, "", std::move(description)) {};
 
 Node::Input& Node::InputMap::operator[](const std::string& key) {
     if(count({name, key}) == 0) {
diff --git a/src/pipeline/node/DetectionNetwork.cpp b/src/pipeline/node/DetectionNetwork.cpp
index f83cae4beb..d2815f2869 100644
--- a/src/pipeline/node/DetectionNetwork.cpp
+++ b/src/pipeline/node/DetectionNetwork.cpp
@@ -27,11 +27,8 @@ namespace node {
 //--------------------------------------------------------------------
 
 DetectionNetwork::DetectionNetwork(const std::shared_ptr<Device>& device)
-    : DeviceNodeGroup(device),
-      out{detectionParser->out},
-      outNetwork{neuralNetwork->out},
-      input{neuralNetwork->input},
-      passthrough{neuralNetwork->passthrough} {};
+    : DeviceNodeGroup(device), out{detectionParser->out}, outNetwork{neuralNetwork->out}, input{neuralNetwork->input}, passthrough{neuralNetwork->passthrough} {
+      };
 
 // -------------------------------------------------------------------
 // Neural Network API
diff --git a/src/utility/LogCollection.cpp b/src/utility/LogCollection.cpp
index 90f319fac1..3c653cc43f 100644
--- a/src/utility/LogCollection.cpp
+++ b/src/utility/LogCollection.cpp
@@ -59,6 +59,8 @@ std::string protocolToString(XLinkProtocol_t protocol) {
             return "X_LINK_LOCAL_SHDMEM";
         case X_LINK_TCP_IP_OR_LOCAL_SHDMEM:
             return "X_LINK_TCP_IP_OR_LOCAL_SHDMEM";
+        case X_LINK_USB_EP:
+            return "X_LINK_USB_EP";
         case X_LINK_NMB_OF_PROTOCOLS:
             return "X_LINK_NMB_OF_PROTOCOLS";
         case X_LINK_ANY_PROTOCOL:
diff --git a/src/utility/MemoryWrappers.cpp b/src/utility/MemoryWrappers.cpp
index d7228b1549..9aa1bfdf5c 100644
--- a/src/utility/MemoryWrappers.cpp
+++ b/src/utility/MemoryWrappers.cpp
@@ -2,7 +2,7 @@
 
 // memfd_create wrapper for glibc < 2.27
 #if defined(__unix__) && !defined(__APPLE__)
-    #if(__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 27)
+    #if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 27)
         #include <sys/syscall.h>
 
         #ifndef SYS_memfd_create
diff --git a/src/utility/ObjectTrackerImpl.cpp b/src/utility/ObjectTrackerImpl.cpp
index add49d00cd..d20c69f1db 100644
--- a/src/utility/ObjectTrackerImpl.cpp
+++ b/src/utility/ObjectTrackerImpl.cpp
@@ -168,7 +168,7 @@ class OCSTracker::State {
     };
     class KalmanBoxTracker {
        public:
-        KalmanBoxTracker(){};
+        KalmanBoxTracker() {};
         KalmanBoxTracker(Eigen::VectorXf bbox_, int cls_, int delta_t_ = 3);
         void update(Eigen::Matrix<float, 5, 1>* bbox_, int cls_);
         Eigen::RowVectorXf predict();
diff --git a/src/utility/Platform.cpp b/src/utility/Platform.cpp
index d631f5218d..d2cadd0fce 100644
--- a/src/utility/Platform.cpp
+++ b/src/utility/Platform.cpp
@@ -40,7 +40,7 @@ uint32_t getIPv4AddressAsBinary(std::string address) {
     }
 
 #if defined(_WIN32) || defined(__USE_W32_SOCKETS)
-    #if(_WIN32_WINNT <= 0x0501)
+    #if (_WIN32_WINNT <= 0x0501)
     binary = inet_addr(address.c_str());  // for XP
     #else
     inet_pton(AF_INET, address.c_str(), &binary);  // for Vista or higher
@@ -202,7 +202,7 @@ void FSLock::lock() {
         throw std::runtime_error("Failed to open file: " + lockPath.string());
     }
 
-    struct flock fl {};
+    struct flock fl{};
     fl.l_type = F_WRLCK;
     fl.l_whence = SEEK_SET;
     fl.l_start = 0;
@@ -227,7 +227,7 @@ void FSLock::unlock() {
     CloseHandle(handle);
     handle = INVALID_HANDLE_VALUE;
 #else
-    struct flock fl {};
+    struct flock fl{};
     fl.l_type = F_UNLCK;
     fl.l_whence = SEEK_SET;
     fl.l_start = 0;
diff --git a/tests/run_tests.py b/tests/run_tests.py
index 9a4d291b6b..88da13aeb9 100644
--- a/tests/run_tests.py
+++ b/tests/run_tests.py
@@ -112,10 +112,16 @@ def compute_or_result(results):
             "labels": ["onhost"],
         },
         {
-            "name": "RVC4",
-            "env": {"DEPTHAI_PLATFORM": "rvc4"},
+            "name": "RVC4 - USB",
+            "env": {"DEPTHAI_PLATFORM": "rvc4", "DEPTHAI_PROTOCOL": "usb"},
             "labels": ["rvc4"],
         },
+        {
+            "name": "RVC4 - POE",
+            "env": {"DEPTHAI_PLATFORM": "rvc4", "DEPTHAI_PROTOCOL": "tcpip"},
+            "labels": ["rvc4"],
+        },
+
         {
             "name": "RVC4 - RGB",
             "env": {"DEPTHAI_PLATFORM": "rvc4"},