diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
index bc74f0fb350c4f..c072e8bbf2ab18 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/network.hpp
@@ -6,13 +6,13 @@
 
 #include "intel_gpu/graph/topology.hpp"
 #include "intel_gpu/graph/program.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 #include "intel_gpu/runtime/compounds.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 #include "intel_gpu/runtime/engine.hpp"
 #include "intel_gpu/runtime/event.hpp"
 #include "intel_gpu/runtime/stream.hpp"
 #include "intel_gpu/runtime/lru_cache.hpp"
-#include "serialization/binary_buffer.hpp"
 
 #include <map>
 #include <vector>
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/binary_buffer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
similarity index 81%
rename from src/plugins/intel_gpu/src/graph/include/serialization/binary_buffer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
index 1d211cc6d5caf4..84563bc8ead854 100644
--- a/src/plugins/intel_gpu/src/graph/include/serialization/binary_buffer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp
@@ -19,9 +19,8 @@ class BinaryOutputBuffer : public OutputBuffer<BinaryOutputBuffer> {
 
     void write(void const * data, std::streamsize size) {
         auto const written_size = stream.rdbuf()->sputn(reinterpret_cast<const char*>(data), size);
-        if (written_size != size) {
-            throw std::runtime_error("Failed to write " + std::to_string(size) + " bytes to stream! Wrote " + std::to_string(written_size));
-        }
+        OPENVINO_ASSERT(written_size == size,
+            "[GPU] Failed to write " + std::to_string(size) + " bytes to stream! Wrote " + std::to_string(written_size));
     }
 
     void setKernlImplParams(void* impl_params) { _impl_params = impl_params; }
@@ -38,9 +37,8 @@ class BinaryInputBuffer : public InputBuffer<BinaryInputBuffer> {
 
     void read(void* const data, std::streamsize size) {
         auto const read_size = stream.rdbuf()->sgetn(reinterpret_cast<char*>(data), size);
-        if (read_size != size) {
-            throw std::runtime_error("Failed to read " + std::to_string(size) + " bytes from stream! Read " + std::to_string(read_size));
-        }
+        OPENVINO_ASSERT(read_size == size,
+            "[GPU] Failed to read " + std::to_string(size) + " bytes from stream! Read " + std::to_string(read_size));
     }
 
     void setKernlImplParams(void* impl_params) { _impl_params = impl_params; }
@@ -85,9 +83,14 @@ class Serializer<BinaryInputBuffer, Data<T>> {
 
 }  // namespace cldnn
 
-#define BIND_BINARY_BUFFER_WITH_TYPE(cls_name, obj_type) \
+#define ASSIGN_TYPE_NAME(cls_name) \
             namespace cldnn {                            \
-            const object_type cls_name::type = obj_type; \
+            const std::string cls_name::type = #cls_name; \
+            }
+
+#define BIND_BINARY_BUFFER_WITH_TYPE(cls_name) \
+            namespace cldnn {                            \
+            const std::string cls_name::type = #cls_name; \
             BIND_TO_BUFFER(BinaryOutputBuffer, cls_name) \
             BIND_TO_BUFFER(BinaryInputBuffer, cls_name)  \
             }
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/bind.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/bind.hpp
similarity index 86%
rename from src/plugins/intel_gpu/src/graph/include/serialization/bind.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/bind.hpp
index 9002eaf209373a..67c98b087c787c 100644
--- a/src/plugins/intel_gpu/src/graph/include/serialization/bind.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/bind.hpp
@@ -10,11 +10,10 @@
 #include <functional>
 #include "buffer.hpp"
 #include "static_instance.hpp"
-#include "object_types.hpp"
 
 #define DECLARE_OBJECT_TYPE_SERIALIZATION \
-    static const object_type type; \
-    object_type get_type() const override { return type; }
+    static const std::string type; \
+    std::string get_type() const override { return type; }
 
 #define BIND_TO_BUFFER(buffer, type)                                                       \
         template <>                                                                        \
@@ -25,26 +24,19 @@
         const instance_creator<buffer, type>& bind_creator<buffer, type>::creator =        \
             static_instance<instance_creator<buffer, type>>::get_instance().instantiate();
 
-// It's a defect, and was fixed in C++14
-// https://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148
-struct enum_class_hash {
-    template <typename T>
-    std::size_t operator()(T t) const { return static_cast<std::size_t>(t); }
-};
-
 namespace cldnn {
 
 template <typename BufferType>
 struct saver_storage {
     using save_function = std::function<void(BufferType&, const void*)>;
-    using value_type = typename std::unordered_map<object_type, save_function, enum_class_hash>::value_type;
+    using value_type = typename std::unordered_map<std::string, save_function>::value_type;
 
     static saver_storage<BufferType>& instance() {
         static saver_storage<BufferType> instance;
         return instance;
     }
 
-    const save_function& get_save_function(const object_type& type) const {
+    const save_function& get_save_function(const std::string& type) const {
         return map.at(type);
     }
 
@@ -57,7 +49,7 @@ struct saver_storage {
     saver_storage(const saver_storage&) = delete;
     void operator=(const saver_storage&) = delete;
 
-    std::unordered_map<object_type, save_function, enum_class_hash> map;
+    std::unordered_map<std::string, save_function> map;
 };
 
 template <typename T>
@@ -67,14 +59,14 @@ struct void_deleter {
 
 template <typename BufferType, typename FuncT>
 struct loader_storage {
-    using value_type = typename std::unordered_map<object_type, FuncT, enum_class_hash>::value_type;
+    using value_type = typename std::unordered_map<std::string, FuncT>::value_type;
 
     static loader_storage& instance() {
         static loader_storage instance;
         return instance;
     }
 
-    const FuncT& get_load_function(const object_type& type) {
+    const FuncT& get_load_function(const std::string& type) {
         return map.at(type);
     }
 
@@ -87,7 +79,7 @@ struct loader_storage {
     loader_storage(const loader_storage&) = delete;
     void operator=(const loader_storage&) = delete;
 
-    std::unordered_map<object_type, FuncT, enum_class_hash> map;
+    std::unordered_map<std::string, FuncT> map;
 };
 
 template <typename BufferType>
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/buffer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/buffer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/buffer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/buffer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/cl_kernel_data_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/cl_kernel_data_serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/cl_kernel_data_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/cl_kernel_data_serializer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/helpers.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/helpers.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/helpers.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/helpers.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/layout_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
similarity index 58%
rename from src/plugins/intel_gpu/src/graph/include/serialization/layout_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
index 31c1ebdc68f8ad..a73c1c7d0c20d7 100644
--- a/src/plugins/intel_gpu/src/graph/include/serialization/layout_serializer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp
@@ -12,6 +12,33 @@
 #include "intel_gpu/runtime/layout.hpp"
 
 namespace cldnn {
+template <typename BufferType>
+class Serializer<BufferType, ov::PartialShape, typename std::enable_if<std::is_base_of<OutputBuffer<BufferType>, BufferType>::value>::type> {
+public:
+    static void save(BufferType& buffer, const ov::PartialShape& partial_shape) {
+        std::vector<ov::Dimension> dimensions(partial_shape);
+        buffer << dimensions.size();
+        for (const auto& dimension : dimensions) {
+            buffer << dimension.get_interval().get_min_val();
+            buffer << dimension.get_interval().get_max_val();
+        }
+    }
+};
+
+template <typename BufferType>
+class Serializer<BufferType, ov::PartialShape, typename std::enable_if<std::is_base_of<InputBuffer<BufferType>, BufferType>::value>::type> {
+public:
+    static void load(BufferType& buffer, ov::PartialShape& partial_shape) {
+        size_t num_dimensions;
+        buffer >> num_dimensions;
+        for (size_t i = 0; i < num_dimensions; i++) {
+            ov::Dimension::value_type min_val, max_val;
+            buffer >> min_val >> max_val;
+            partial_shape.push_back(ov::Dimension(min_val, max_val));
+        }
+    }
+};
+
 template <typename BufferType>
 class Serializer<BufferType, cldnn::layout, typename std::enable_if<std::is_base_of<OutputBuffer<BufferType>, BufferType>::value>::type> {
 public:
@@ -21,15 +48,7 @@ class Serializer<BufferType, cldnn::layout, typename std::enable_if<std::is_base
         buffer << _layout.data_padding.filling_value();
         buffer << _layout.data_padding.lower_size().sizes();
         buffer << _layout.data_padding.upper_size().sizes();
-
-        std::vector<cldnn::tensor::value_type> _sizes = _layout.get_tensor().sizes(_layout.format);
-        // Temp WA for bs_x_bsv16
-        if (_layout.format == cldnn::format::bs_x_bsv16) {
-            std::vector<cldnn::tensor::value_type> _tmp_sizes = _layout.get_tensor().sizes();
-            _sizes[0] = _tmp_sizes[0];
-            _sizes[1] = _tmp_sizes[1];
-        }
-        buffer << _sizes;
+        buffer << _layout.get_partial_shape();
     }
 };
 
@@ -50,15 +69,9 @@ class Serializer<BufferType, cldnn::layout, typename std::enable_if<std::is_base
             _layout.data_padding = cldnn::padding(_lower_size, _upper_size, _filling_value);
         }
 
-        std::vector<cldnn::tensor::value_type> _sizes;
-        buffer >> _sizes;
-
-        // Temp WA for bs_x_bsv16
-        if (_layout.format == cldnn::format::bs_x_bsv16) {
-            _layout.set_tensor(tensor(_sizes));
-        } else {
-            _layout.set_tensor(tensor(_layout.format, _sizes));
-        }
+        ov::PartialShape partial_shape;
+        buffer >> partial_shape;
+        _layout.set_partial_shape(partial_shape);
     }
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/map_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/map_serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/map_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/map_serializer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/polymorphic_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/polymorphic_serializer.hpp
similarity index 86%
rename from src/plugins/intel_gpu/src/graph/include/serialization/polymorphic_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/polymorphic_serializer.hpp
index b6d7dd730eb186..e85ef7f6150066 100644
--- a/src/plugins/intel_gpu/src/graph/include/serialization/polymorphic_serializer.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/polymorphic_serializer.hpp
@@ -12,7 +12,6 @@
 #include "buffer.hpp"
 #include "bind.hpp"
 #include "helpers.hpp"
-#include "object_types.hpp"
 
 namespace cldnn {
 
@@ -21,7 +20,7 @@ class Serializer<BufferType, std::unique_ptr<T>, typename std::enable_if<std::is
 public:
     static void save(BufferType& buffer, const std::unique_ptr<T>& ptr) {
         const auto& type = ptr->get_type();
-        buffer << cldnn::make_data(&type, sizeof(object_type));
+        buffer << type;
         const auto save_func = saver_storage<BufferType>::instance().get_save_function(type);
         save_func(buffer, ptr.get());
     }
@@ -31,8 +30,8 @@ template <typename BufferType, typename T>
 class Serializer<BufferType, std::unique_ptr<T>, typename std::enable_if<std::is_base_of<InputBuffer<BufferType>, BufferType>::value>::type> {
 public:
     static void load(BufferType& buffer, std::unique_ptr<T>& ptr, engine& engine) {
-        object_type type;
-        buffer >> cldnn::make_data(&type, sizeof(object_type));
+        std::string type;
+        buffer >> type;
         const auto load_func = dif<BufferType>::instance().get_load_function(type);
         std::unique_ptr<void, void_deleter<void>> result;
         load_func(buffer, result, engine);
@@ -40,8 +39,8 @@ class Serializer<BufferType, std::unique_ptr<T>, typename std::enable_if<std::is
     }
 
     static void load(BufferType& buffer, std::unique_ptr<T>& ptr) {
-        object_type type;
-        buffer >> cldnn::make_data(&type, sizeof(object_type));
+        std::string type;
+        buffer >> type;
         const auto load_func = def<BufferType>::instance().get_load_function(type);
         std::unique_ptr<void, void_deleter<void>> result;
         load_func(buffer, result);
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/serializer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/set_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/set_serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/set_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/set_serializer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/static_instance.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/static_instance.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/static_instance.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/static_instance.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/string_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/string_serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/string_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/string_serializer.hpp
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/vector_serializer.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp
similarity index 100%
rename from src/plugins/intel_gpu/src/graph/include/serialization/vector_serializer.hpp
rename to src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp
diff --git a/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp b/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
index 09aa0a03bf7cb2..ab82970a24da50 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/plugin/compiled_model.hpp
@@ -28,7 +28,6 @@ class CompiledModel : public InferenceEngine::ExecutableNetworkThreadSafeDefault
     CompiledModel(std::istream& networkModel, std::shared_ptr<InferenceEngine::RemoteContext> context, Config config);
 
     void Export(std::ostream& networkModel) override;
-    bool isSerializable();
     std::shared_ptr<ngraph::Function> GetExecGraphInfo() override;
     InferenceEngine::IInferRequestInternal::Ptr CreateInferRequest() override;
     InferenceEngine::IInferRequestInternal::Ptr CreateInferRequestImpl(InferenceEngine::InputsDataMap networkInputs,
@@ -47,6 +46,9 @@ class CompiledModel : public InferenceEngine::ExecutableNetworkThreadSafeDefault
     Config m_config;
     InferenceEngine::ITaskExecutor::Ptr m_taskExecutor;
     InferenceEngine::ITaskExecutor::Ptr m_waitExecutor;
+
+private:
+    bool is_serializable();
 };
 
 }  // namespace intel_gpu
diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
index 5f3caabec22d24..643c5e1b0e7577 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
@@ -213,6 +213,30 @@ struct primitive_info {
     CLDNN_DEFINE_TYPE_ID(PType)              \
     CLDNN_DEFINE_TYPE_STRING(PType)
 
+#define GPU_DEFINE_PRIMITIVE_TYPE_ID(PType)             \
+    primitive_type_id PType::type_id() {                \
+        static primitive_type_base<PType> instance;     \
+        return &instance;                               \
+    }                                                   \
+    bool _##PType##_added_ = prim_map_storage::instance().set_type_id(#PType, PType::type_id());
+
+struct prim_map_storage {
+    static prim_map_storage& instance() {
+        static prim_map_storage instance;
+        return instance;
+    }
+
+    const cldnn::primitive_type_id get_type_id(const std::string& type_string) const {
+        return map.at(type_string);
+    }
+
+    bool set_type_id(const std::string& type_string, const cldnn::primitive_type_id type_id) {
+        return map.insert({type_string, type_id}).second;
+    }
+
+private:
+    std::unordered_map<std::string, cldnn::primitive_type_id> map;
+};
 /// @}
 /// @}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/activation.cpp b/src/plugins/intel_gpu/src/graph/activation.cpp
index 5548c5e4737af4..2cc58e463eee43 100644
--- a/src/plugins/intel_gpu/src/graph/activation.cpp
+++ b/src/plugins/intel_gpu/src/graph/activation.cpp
@@ -10,10 +10,7 @@
 #include <vector>
 
 namespace cldnn {
-primitive_type_id activation::type_id() {
-    static primitive_type_base<activation> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(activation)
 
 layout activation_inst::calc_output_layout(activation_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/adaptive_pooling.cpp b/src/plugins/intel_gpu/src/graph/adaptive_pooling.cpp
index bbf23ce8bda55b..bf1a39d5710594 100644
--- a/src/plugins/intel_gpu/src/graph/adaptive_pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/adaptive_pooling.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id adaptive_pooling::type_id() {
-    static primitive_type_base<adaptive_pooling> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(adaptive_pooling)
 
 layout adaptive_pooling_inst::calc_output_layout(const adaptive_pooling_node& node, kernel_impl_params const& impl_param) {
     const auto data_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/arg_max_min.cpp b/src/plugins/intel_gpu/src/graph/arg_max_min.cpp
index 8cd4ad4b9e0933..b9de9df34344de 100644
--- a/src/plugins/intel_gpu/src/graph/arg_max_min.cpp
+++ b/src/plugins/intel_gpu/src/graph/arg_max_min.cpp
@@ -13,10 +13,7 @@
 #include "topk_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id arg_max_min::type_id() {
-    static primitive_type_base<arg_max_min> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(arg_max_min)
 
 layout arg_max_min_inst::calc_output_layout(arg_max_min_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<arg_max_min>();
diff --git a/src/plugins/intel_gpu/src/graph/assign.cpp b/src/plugins/intel_gpu/src/graph/assign.cpp
index 8d0219a5d23afe..8a0600ff69271a 100644
--- a/src/plugins/intel_gpu/src/graph/assign.cpp
+++ b/src/plugins/intel_gpu/src/graph/assign.cpp
@@ -9,11 +9,7 @@
 #include <data_inst.h>
 
 namespace cldnn {
-
-primitive_type_id assign::type_id() {
-    static primitive_type_base<assign> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(assign)
 
 assign_inst::typed_primitive_inst(network& network, const assign_node& node) :
     parent{network, node, false},
diff --git a/src/plugins/intel_gpu/src/graph/average_unpooling.cpp b/src/plugins/intel_gpu/src/graph/average_unpooling.cpp
index c667e10454844f..eb3156d4351bb8 100644
--- a/src/plugins/intel_gpu/src/graph/average_unpooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/average_unpooling.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id average_unpooling::type_id() {
-    static primitive_type_base<average_unpooling> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(average_unpooling)
 
 layout average_unpooling_inst::calc_output_layout(average_unpooling_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/batch_to_space.cpp b/src/plugins/intel_gpu/src/graph/batch_to_space.cpp
index 78c5e2f18f588d..f8d5a446f3c6cb 100644
--- a/src/plugins/intel_gpu/src/graph/batch_to_space.cpp
+++ b/src/plugins/intel_gpu/src/graph/batch_to_space.cpp
@@ -12,10 +12,7 @@
 #include <vector>
 
 namespace cldnn {
-primitive_type_id cldnn::batch_to_space::type_id() {
-    static primitive_type_base<batch_to_space> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(batch_to_space)
 
 layout batch_to_space_inst::calc_output_layout(batch_to_space_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<batch_to_space>();
diff --git a/src/plugins/intel_gpu/src/graph/binary_convolution.cpp b/src/plugins/intel_gpu/src/graph/binary_convolution.cpp
index 05227380d03993..dea33e35e5a454 100644
--- a/src/plugins/intel_gpu/src/graph/binary_convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/binary_convolution.cpp
@@ -12,10 +12,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id binary_convolution::type_id() {
-    static primitive_type_base<binary_convolution> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(binary_convolution)
 
 layout binary_convolution_inst::calc_output_layout(binary_convolution_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<binary_convolution>();
diff --git a/src/plugins/intel_gpu/src/graph/border.cpp b/src/plugins/intel_gpu/src/graph/border.cpp
index e0f7b6b9dd7ecb..8baec60eccef6f 100644
--- a/src/plugins/intel_gpu/src/graph/border.cpp
+++ b/src/plugins/intel_gpu/src/graph/border.cpp
@@ -12,10 +12,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id border::type_id() {
-    static primitive_type_base<border> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(border)
 
 layout border_inst::calc_output_layout(border_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/broadcast.cpp b/src/plugins/intel_gpu/src/graph/broadcast.cpp
index da7db6525b72f2..e780b00e014cc2 100644
--- a/src/plugins/intel_gpu/src/graph/broadcast.cpp
+++ b/src/plugins/intel_gpu/src/graph/broadcast.cpp
@@ -13,10 +13,7 @@
 #include <set>
 
 namespace cldnn {
-primitive_type_id broadcast::type_id() {
-    static primitive_type_base<broadcast> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(broadcast)
 
 layout broadcast_inst::calc_output_layout(broadcast_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/bucketize.cpp b/src/plugins/intel_gpu/src/graph/bucketize.cpp
index 1ffab6fbb494be..78740d10161395 100644
--- a/src/plugins/intel_gpu/src/graph/bucketize.cpp
+++ b/src/plugins/intel_gpu/src/graph/bucketize.cpp
@@ -11,11 +11,7 @@
 #include "to_string_utils.h"
 
 namespace cldnn {
-
-primitive_type_id bucketize::type_id() {
-    static primitive_type_base<bucketize> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(bucketize)
 
 layout bucketize_inst::calc_output_layout(const bucketize_node& node, kernel_impl_params const& impl_param) {
     auto input_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/concatenation.cpp b/src/plugins/intel_gpu/src/graph/concatenation.cpp
index 61a75e7822ff73..03b53a192547a0 100644
--- a/src/plugins/intel_gpu/src/graph/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/concatenation.cpp
@@ -12,10 +12,7 @@
 #include <list>
 
 namespace cldnn {
-primitive_type_id concatenation::type_id() {
-    static primitive_type_base<concatenation> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(concatenation)
 
 layout concatenation_inst::calc_output_layout(concatenation_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<concatenation>();
diff --git a/src/plugins/intel_gpu/src/graph/condition.cpp b/src/plugins/intel_gpu/src/graph/condition.cpp
index 0b20a19e4606f0..c9990b6cbe0d86 100644
--- a/src/plugins/intel_gpu/src/graph/condition.cpp
+++ b/src/plugins/intel_gpu/src/graph/condition.cpp
@@ -10,10 +10,8 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id condition::type_id() {
-    static primitive_type_base<condition> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(condition)
+
 /*
     Calc_output_layout method is called only when output layout is invalidated.
     It means, that it is called when:
diff --git a/src/plugins/intel_gpu/src/graph/convert_color.cpp b/src/plugins/intel_gpu/src/graph/convert_color.cpp
index 9af11fd3a5c38c..ca6f1e5979c066 100644
--- a/src/plugins/intel_gpu/src/graph/convert_color.cpp
+++ b/src/plugins/intel_gpu/src/graph/convert_color.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id convert_color::type_id() {
-    static primitive_type_base<convert_color> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(convert_color)
 
 layout convert_color_inst::calc_output_layout(convert_color_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<convert_color>();
diff --git a/src/plugins/intel_gpu/src/graph/convolution.cpp b/src/plugins/intel_gpu/src/graph/convolution.cpp
index 2c0ff9e3a4f691..d3eb13a6594c1c 100644
--- a/src/plugins/intel_gpu/src/graph/convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/convolution.cpp
@@ -15,10 +15,7 @@
 using namespace ov::intel_gpu;
 
 namespace cldnn {
-primitive_type_id convolution::type_id() {
-    static primitive_type_base<convolution> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(convolution)
 
 layout convolution_inst::calc_output_layout(convolution_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<convolution>();
diff --git a/src/plugins/intel_gpu/src/graph/crop.cpp b/src/plugins/intel_gpu/src/graph/crop.cpp
index ac08034a757637..fcd0ed28bdfc91 100644
--- a/src/plugins/intel_gpu/src/graph/crop.cpp
+++ b/src/plugins/intel_gpu/src/graph/crop.cpp
@@ -14,10 +14,7 @@
 #include "split_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id crop::type_id() {
-    static primitive_type_base<crop> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(crop)
 
 layout crop_inst::calc_output_layout(crop_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/ctc_greedy_decoder.cpp b/src/plugins/intel_gpu/src/graph/ctc_greedy_decoder.cpp
index 853b28086ae975..f79edd2de7d084 100644
--- a/src/plugins/intel_gpu/src/graph/ctc_greedy_decoder.cpp
+++ b/src/plugins/intel_gpu/src/graph/ctc_greedy_decoder.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id ctc_greedy_decoder::type_id() {
-    static primitive_type_base<ctc_greedy_decoder> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(ctc_greedy_decoder)
 
 layout ctc_greedy_decoder_inst::calc_output_layout(ctc_greedy_decoder_node const& node, kernel_impl_params const& impl_param) {
     auto input_node_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/ctc_loss.cpp b/src/plugins/intel_gpu/src/graph/ctc_loss.cpp
index 42dfa9a0dd70fc..52d3bdbdc38954 100644
--- a/src/plugins/intel_gpu/src/graph/ctc_loss.cpp
+++ b/src/plugins/intel_gpu/src/graph/ctc_loss.cpp
@@ -11,11 +11,7 @@
 #include "to_string_utils.h"
 
 namespace cldnn {
-
-primitive_type_id ctc_loss::type_id() {
-    static primitive_type_base<ctc_loss> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(ctc_loss)
 
 layout ctc_loss_inst::calc_output_layout(const ctc_loss_node& node, const kernel_impl_params& impl_param) {
     auto input_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/cum_sum.cpp b/src/plugins/intel_gpu/src/graph/cum_sum.cpp
index 28b87db68a4fed..5acb7da9e04186 100644
--- a/src/plugins/intel_gpu/src/graph/cum_sum.cpp
+++ b/src/plugins/intel_gpu/src/graph/cum_sum.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id cum_sum::type_id() {
-    static primitive_type_base<cum_sum> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(cum_sum)
 
 layout cum_sum_inst::calc_output_layout(cum_sum_node const& node, kernel_impl_params const& impl_param) {
     return impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/custom_gpu_primitive.cpp b/src/plugins/intel_gpu/src/graph/custom_gpu_primitive.cpp
index 06a93587a52d76..cdd0f5f6aa9354 100644
--- a/src/plugins/intel_gpu/src/graph/custom_gpu_primitive.cpp
+++ b/src/plugins/intel_gpu/src/graph/custom_gpu_primitive.cpp
@@ -10,11 +10,7 @@
 #include <string>
 
 namespace cldnn {
-
-primitive_type_id custom_gpu_primitive::type_id() {
-    static primitive_type_base<custom_gpu_primitive> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(custom_gpu_primitive)
 
 std::string custom_gpu_primitive_inst::to_string(custom_gpu_primitive_node const& node) {
     auto desc = node.get_primitive();
diff --git a/src/plugins/intel_gpu/src/graph/data.cpp b/src/plugins/intel_gpu/src/graph/data.cpp
index f6cfebcf53259a..e6c618133d987e 100644
--- a/src/plugins/intel_gpu/src/graph/data.cpp
+++ b/src/plugins/intel_gpu/src/graph/data.cpp
@@ -13,10 +13,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id data::type_id() {
-    static primitive_type_base<data> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(data)
 
 namespace {
 memory::ptr attach_or_copy_data(network& network, memory::ptr mem) {
@@ -56,4 +53,48 @@ std::string data_inst::to_string(data_node const& node) {
 data_inst::typed_primitive_inst(network& network, data_node const& node)
     : parent(network, node, attach_or_copy_data(network, node.get_attached_memory_ptr())) {}
 
+// Cache blob format:
+//     [ kernel_impl_params ]
+//     [ output memory information ]
+//     [ data stored in memory ]
+void data_inst::save(cldnn::BinaryOutputBuffer& ob) const {
+    parent::save(ob);
+    ob << _outputs[0]->get_layout();
+
+    const auto _allocation_type = _outputs[0]->get_allocation_type();
+    ob << make_data(&_allocation_type, sizeof(_allocation_type));
+
+    size_t data_size = _outputs[0]->size();
+    ob << make_data(&data_size, sizeof(size_t));
+
+    if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+        ob << make_data(_outputs[0]->buffer_ptr(), data_size);
+    } else {
+        mem_lock<char, mem_lock_type::read> lock{_outputs[0], get_node().get_program().get_stream()};
+        ob << make_data(lock.data(), data_size);
+    }
+}
+
+void data_inst::load(BinaryInputBuffer& ib) {
+    parent::load(ib);
+    layout output_layout = layout();
+    ib >> output_layout;
+
+    allocation_type _allocation_type;
+    ib >> make_data(&_allocation_type, sizeof(_allocation_type));
+
+    size_t data_size;
+    ib >> make_data(&data_size, sizeof(size_t));
+    _outputs[0] = get_network().get_memory_pool().get_memory(output_layout, _allocation_type, false);
+
+    if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
+        ib >> make_data(_outputs[0]->buffer_ptr(), data_size);
+    } else {
+        std::vector<uint8_t> _buf;
+        _buf.resize(data_size);
+        ib >> make_data(_buf.data(), data_size);
+        _outputs[0]->copy_from(get_network().get_stream(), _buf.data());
+    }
+}
+
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/deconvolution.cpp b/src/plugins/intel_gpu/src/graph/deconvolution.cpp
index dac38d87a7577a..d5d88af713055c 100644
--- a/src/plugins/intel_gpu/src/graph/deconvolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/deconvolution.cpp
@@ -13,10 +13,7 @@
 using namespace ov::intel_gpu;
 
 namespace cldnn {
-primitive_type_id deconvolution::type_id() {
-    static primitive_type_base<deconvolution> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(deconvolution)
 
 layout deconvolution_inst::calc_output_layout(deconvolution_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/deformable_convolution.cpp b/src/plugins/intel_gpu/src/graph/deformable_convolution.cpp
index ff9b969c34ae2e..3acb451b46dac9 100644
--- a/src/plugins/intel_gpu/src/graph/deformable_convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/deformable_convolution.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id deformable_conv::type_id() {
-    static primitive_type_base<deformable_conv> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(deformable_conv)
 
 layout deformable_conv_inst::calc_output_layout(deformable_conv_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<deformable_conv>();
@@ -56,10 +53,7 @@ std::string deformable_conv_inst::to_string(deformable_conv_node const& node) {
 deformable_conv_inst::typed_primitive_inst(network& network, deformable_conv_node const& node) : parent(network, node) {
 }
 
-primitive_type_id deformable_interp::type_id() {
-    static primitive_type_base<deformable_interp> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(deformable_interp)
 
 layout deformable_interp_inst::calc_output_layout(deformable_interp_node const& node, kernel_impl_params const& impl_param) {
     auto desc = node.get_primitive();
diff --git a/src/plugins/intel_gpu/src/graph/depth_to_space.cpp b/src/plugins/intel_gpu/src/graph/depth_to_space.cpp
index cd2d54350727b1..01c01ccd941d73 100644
--- a/src/plugins/intel_gpu/src/graph/depth_to_space.cpp
+++ b/src/plugins/intel_gpu/src/graph/depth_to_space.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id depth_to_space::type_id() {
-    static primitive_type_base<depth_to_space> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(depth_to_space)
 
 layout depth_to_space_inst::calc_output_layout(depth_to_space_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<depth_to_space>();
diff --git a/src/plugins/intel_gpu/src/graph/detection_output.cpp b/src/plugins/intel_gpu/src/graph/detection_output.cpp
index c25ca051922148..06f8b30e915c41 100644
--- a/src/plugins/intel_gpu/src/graph/detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/detection_output.cpp
@@ -4,16 +4,13 @@
 
 #include "detection_output_inst.h"
 #include "primitive_type_base.h"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
 #include "intel_gpu/runtime/error_handler.hpp"
 #include "json_object.h"
 #include <string>
-#include "serialization/string_serializer.hpp"
 
 namespace cldnn {
-primitive_type_id detection_output::type_id() {
-    static primitive_type_base<detection_output> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(detection_output)
 
 layout detection_output_inst::calc_output_layout(detection_output_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
@@ -189,7 +186,7 @@ void detection_output_inst::save(cldnn::BinaryOutputBuffer& ob) const {
     ob << argument->input[0];
     ob << argument->input[1];
     ob << argument->input[2];
-    ob << cldnn::make_data(&argument->output_padding, sizeof(argument->output_padding));
+    ob << make_data(&argument->output_padding, sizeof(argument->output_padding));
     ob << argument->num_classes;
     ob << argument->keep_top_k;
     ob << argument->share_location;
@@ -197,7 +194,7 @@ void detection_output_inst::save(cldnn::BinaryOutputBuffer& ob) const {
     ob << argument->nms_threshold;
     ob << argument->top_k;
     ob << argument->eta;
-    ob << cldnn::make_data(&argument->code_type, sizeof(argument->code_type));
+    ob << make_data(&argument->code_type, sizeof(argument->code_type));
     ob << argument->variance_encoded_in_target;
     ob << argument->confidence_threshold;
     ob << argument->prior_info_size;
@@ -242,7 +239,7 @@ void detection_output_inst::load(cldnn::BinaryInputBuffer& ib) {
     ib >> input_location;
     ib >> input_confidence;
     ib >> input_prior_box;
-    ib >> cldnn::make_data(&output_padding, sizeof(output_padding));
+    ib >> make_data(&output_padding, sizeof(output_padding));
     ib >> num_classes;
     ib >> keep_top_k;
     ib >> share_location;
@@ -250,7 +247,7 @@ void detection_output_inst::load(cldnn::BinaryInputBuffer& ib) {
     ib >> nms_threshold;
     ib >> top_k;
     ib >> eta;
-    ib >> cldnn::make_data(&code_type, sizeof(code_type));
+    ib >> make_data(&code_type, sizeof(code_type));
     ib >> variance_encoded_in_target;
     ib >> confidence_threshold;
     ib >> prior_info_size;
diff --git a/src/plugins/intel_gpu/src/graph/dft.cpp b/src/plugins/intel_gpu/src/graph/dft.cpp
index 9cd0459c065dbc..3b0b079646f270 100644
--- a/src/plugins/intel_gpu/src/graph/dft.cpp
+++ b/src/plugins/intel_gpu/src/graph/dft.cpp
@@ -8,11 +8,7 @@
 #include "json_object.h"
 
 namespace cldnn {
-
-primitive_type_id dft::type_id() {
-    static primitive_type_base<dft> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(dft)
 
 layout dft_inst::calc_output_layout(const dft_node& node, const kernel_impl_params& impl_param) {
     const auto primitive = impl_param.typed_desc<dft>();
diff --git a/src/plugins/intel_gpu/src/graph/eltwise.cpp b/src/plugins/intel_gpu/src/graph/eltwise.cpp
index 705fc082461d8e..c38963212616a5 100644
--- a/src/plugins/intel_gpu/src/graph/eltwise.cpp
+++ b/src/plugins/intel_gpu/src/graph/eltwise.cpp
@@ -12,10 +12,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id eltwise::type_id() {
-    static primitive_type_base<eltwise> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(eltwise)
 
 layout eltwise_inst::calc_output_layout(eltwise_node const& node, kernel_impl_params const& impl_param) {
     size_t primary_input_idx = 0;
diff --git a/src/plugins/intel_gpu/src/graph/embedding_bag.cpp b/src/plugins/intel_gpu/src/graph/embedding_bag.cpp
index c2807b7e418917..e2863bfabb6e1a 100644
--- a/src/plugins/intel_gpu/src/graph/embedding_bag.cpp
+++ b/src/plugins/intel_gpu/src/graph/embedding_bag.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id embedding_bag::type_id() {
-    static primitive_type_base<embedding_bag> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(embedding_bag)
 
 layout embedding_bag_inst::calc_output_layout(embedding_bag_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<embedding_bag>();
diff --git a/src/plugins/intel_gpu/src/graph/experimental_detectron_detection_output.cpp b/src/plugins/intel_gpu/src/graph/experimental_detectron_detection_output.cpp
index daaa48fc4c5b9f..63cf986939a2e8 100644
--- a/src/plugins/intel_gpu/src/graph/experimental_detectron_detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/experimental_detectron_detection_output.cpp
@@ -10,10 +10,7 @@
 #include "primitive_type_base.h"
 
 namespace cldnn {
-primitive_type_id experimental_detectron_detection_output::type_id() {
-    static primitive_type_base<experimental_detectron_detection_output> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(experimental_detectron_detection_output)
 
 layout experimental_detectron_detection_output_inst::calc_output_layout(
     const experimental_detectron_detection_output_node& node, kernel_impl_params const& impl_param) {
diff --git a/src/plugins/intel_gpu/src/graph/experimental_detectron_generate_proposal_single_image.cpp b/src/plugins/intel_gpu/src/graph/experimental_detectron_generate_proposal_single_image.cpp
index be56e4aeafede2..4399a9b4d1243a 100644
--- a/src/plugins/intel_gpu/src/graph/experimental_detectron_generate_proposal_single_image.cpp
+++ b/src/plugins/intel_gpu/src/graph/experimental_detectron_generate_proposal_single_image.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id experimental_detectron_generate_proposals_single_image::type_id() {
-    static primitive_type_base<experimental_detectron_generate_proposals_single_image> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(experimental_detectron_generate_proposals_single_image)
 
 layout experimental_detectron_generate_proposals_single_image_inst::calc_output_layout(
         const experimental_detectron_generate_proposals_single_image_node& node, kernel_impl_params const& impl_param) {
diff --git a/src/plugins/intel_gpu/src/graph/experimental_detectron_prior_grid_generator.cpp b/src/plugins/intel_gpu/src/graph/experimental_detectron_prior_grid_generator.cpp
index 23f09d9ed9c8b8..8f92bf87a5386b 100644
--- a/src/plugins/intel_gpu/src/graph/experimental_detectron_prior_grid_generator.cpp
+++ b/src/plugins/intel_gpu/src/graph/experimental_detectron_prior_grid_generator.cpp
@@ -8,11 +8,7 @@
 #include "json_object.h"
 
 namespace cldnn {
-
-primitive_type_id experimental_detectron_prior_grid_generator::type_id() {
-    static primitive_type_base<experimental_detectron_prior_grid_generator> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(experimental_detectron_prior_grid_generator)
 
 layout experimental_detectron_prior_grid_generator_inst::calc_output_layout(
     const experimental_detectron_prior_grid_generator_node& node, kernel_impl_params const& impl_param) {
diff --git a/src/plugins/intel_gpu/src/graph/experimental_detectron_roi_feature_extractor.cpp b/src/plugins/intel_gpu/src/graph/experimental_detectron_roi_feature_extractor.cpp
index 4c39b1b76a3616..5ff14f1d68aa51 100644
--- a/src/plugins/intel_gpu/src/graph/experimental_detectron_roi_feature_extractor.cpp
+++ b/src/plugins/intel_gpu/src/graph/experimental_detectron_roi_feature_extractor.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id experimental_detectron_roi_feature_extractor::type_id() {
-    static primitive_type_base<experimental_detectron_roi_feature_extractor> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(experimental_detectron_roi_feature_extractor)
 
 size_t experimental_detectron_roi_feature_extractor_inst::inputs_memory_count() const {
     return parent::inputs_memory_count() - 1;
diff --git a/src/plugins/intel_gpu/src/graph/experimental_detectron_topk_rois.cpp b/src/plugins/intel_gpu/src/graph/experimental_detectron_topk_rois.cpp
index d3a1d28ec905ef..ce87eb7c085d85 100644
--- a/src/plugins/intel_gpu/src/graph/experimental_detectron_topk_rois.cpp
+++ b/src/plugins/intel_gpu/src/graph/experimental_detectron_topk_rois.cpp
@@ -9,11 +9,7 @@
 #include <data_inst.h>
 
 namespace cldnn {
-
-primitive_type_id experimental_detectron_topk_rois::type_id() {
-    static primitive_type_base<experimental_detectron_topk_rois> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(experimental_detectron_topk_rois)
 
 experimental_detectron_topk_rois_inst::typed_primitive_inst(network& network, experimental_detectron_topk_rois_node const &node)
 : parent(network, node) {
diff --git a/src/plugins/intel_gpu/src/graph/extract_image_patches.cpp b/src/plugins/intel_gpu/src/graph/extract_image_patches.cpp
index c95c3dcbabdddd..a146ec85f29497 100644
--- a/src/plugins/intel_gpu/src/graph/extract_image_patches.cpp
+++ b/src/plugins/intel_gpu/src/graph/extract_image_patches.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id extract_image_patches::type_id() {
-    static primitive_type_base<extract_image_patches> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(extract_image_patches)
 
 layout extract_image_patches_inst::calc_output_layout(extract_image_patches_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<extract_image_patches>();
diff --git a/src/plugins/intel_gpu/src/graph/eye.cpp b/src/plugins/intel_gpu/src/graph/eye.cpp
index 405316d3429c4e..270f270c02cd84 100644
--- a/src/plugins/intel_gpu/src/graph/eye.cpp
+++ b/src/plugins/intel_gpu/src/graph/eye.cpp
@@ -10,11 +10,7 @@
 #include "primitive_type_base.h"
 
 namespace cldnn {
-
-primitive_type_id eye::type_id() {
-    static primitive_type_base<eye> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(eye)
 
 eye_inst::typed_primitive_inst(network& network, eye_node const& node) : parent(network, node) {}
 
diff --git a/src/plugins/intel_gpu/src/graph/fully_connected.cpp b/src/plugins/intel_gpu/src/graph/fully_connected.cpp
index e5dfb9b1fa1723..570fe7f06c0ac8 100644
--- a/src/plugins/intel_gpu/src/graph/fully_connected.cpp
+++ b/src/plugins/intel_gpu/src/graph/fully_connected.cpp
@@ -14,10 +14,7 @@
 #include "matmul_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id fully_connected::type_id() {
-    static primitive_type_base<fully_connected> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(fully_connected)
 
 namespace {
 bool is_batch_after_spatial(const std::string order) {
diff --git a/src/plugins/intel_gpu/src/graph/gather.cpp b/src/plugins/intel_gpu/src/graph/gather.cpp
index 624869bb6117cd..fd8418afb5fb93 100644
--- a/src/plugins/intel_gpu/src/graph/gather.cpp
+++ b/src/plugins/intel_gpu/src/graph/gather.cpp
@@ -12,10 +12,7 @@
 #include "gather_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id gather::type_id() {
-    static primitive_type_base<gather> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gather)
 
 layout gather_inst::calc_output_layout(gather_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<gather>();
diff --git a/src/plugins/intel_gpu/src/graph/gather_elements.cpp b/src/plugins/intel_gpu/src/graph/gather_elements.cpp
index 39c4c5ea86a56b..3f06b2441ff6c7 100644
--- a/src/plugins/intel_gpu/src/graph/gather_elements.cpp
+++ b/src/plugins/intel_gpu/src/graph/gather_elements.cpp
@@ -11,10 +11,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id gather_elements::type_id() {
-    static primitive_type_base<gather_elements> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gather_elements)
 
 layout gather_elements_inst::calc_output_layout(gather_elements_node const& node, kernel_impl_params const& impl_param) {
     auto op = impl_param.typed_desc<gather_elements>();
diff --git a/src/plugins/intel_gpu/src/graph/gather_nd.cpp b/src/plugins/intel_gpu/src/graph/gather_nd.cpp
index 38dfee536a3273..692b50411d1a13 100644
--- a/src/plugins/intel_gpu/src/graph/gather_nd.cpp
+++ b/src/plugins/intel_gpu/src/graph/gather_nd.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id gather_nd::type_id() {
-    static primitive_type_base<gather_nd> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gather_nd)
 
 layout gather_nd_inst::calc_output_layout(gather_nd_node const& node, kernel_impl_params const& impl_param) {
     auto op = impl_param.typed_desc<gather_nd>();
diff --git a/src/plugins/intel_gpu/src/graph/gather_tree.cpp b/src/plugins/intel_gpu/src/graph/gather_tree.cpp
index eb685eda75b503..498385ead947b0 100644
--- a/src/plugins/intel_gpu/src/graph/gather_tree.cpp
+++ b/src/plugins/intel_gpu/src/graph/gather_tree.cpp
@@ -11,10 +11,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id gather_tree::type_id() {
-    static primitive_type_base<gather_tree> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gather_tree)
 
 layout gather_tree_inst::calc_output_layout(gather_tree_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/gemm.cpp b/src/plugins/intel_gpu/src/graph/gemm.cpp
index 06d86e99a98a55..8b3f9e5ac904e6 100644
--- a/src/plugins/intel_gpu/src/graph/gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/gemm.cpp
@@ -14,10 +14,7 @@
 #include "matmul_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id gemm::type_id() {
-    static primitive_type_base<gemm> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gemm)
 
 layout gemm_inst::calc_output_layout(gemm_node const& node, kernel_impl_params const& impl_param) {
     auto prim = impl_param.typed_desc<gemm>();
diff --git a/src/plugins/intel_gpu/src/graph/generate_proposals.cpp b/src/plugins/intel_gpu/src/graph/generate_proposals.cpp
index e27505884ca50d..f0a13313f3fcae 100644
--- a/src/plugins/intel_gpu/src/graph/generate_proposals.cpp
+++ b/src/plugins/intel_gpu/src/graph/generate_proposals.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id generate_proposals::type_id() {
-    static primitive_type_base<generate_proposals> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(generate_proposals)
 
 layout generate_proposals_inst::calc_output_layout(const generate_proposals_node& node, kernel_impl_params const& impl_param) {
     const layout data_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/generic_layer.cpp b/src/plugins/intel_gpu/src/graph/generic_layer.cpp
index f0cfa6f58ad099..a452dab4cc188a 100644
--- a/src/plugins/intel_gpu/src/graph/generic_layer.cpp
+++ b/src/plugins/intel_gpu/src/graph/generic_layer.cpp
@@ -13,11 +13,7 @@
 #include <memory>
 
 namespace cldnn {
-
-primitive_type_id generic_layer::type_id() {
-    static primitive_type_base<generic_layer> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(generic_layer)
 
 generic_layer_node::typed_program_node(const std::shared_ptr<generic_layer> prim, program& prog)
     : parent(prim, prog) {
diff --git a/src/plugins/intel_gpu/src/graph/get_type_id.cpp b/src/plugins/intel_gpu/src/graph/get_type_id.cpp
deleted file mode 100644
index 7e68782abb59f2..00000000000000
--- a/src/plugins/intel_gpu/src/graph/get_type_id.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (C) 2018-2022 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include "primitive_inst.h"
-#include "generic_layer.hpp"
-#include "intel_gpu/primitives/activation.hpp"
-#include "intel_gpu/primitives/adaptive_pooling.hpp"
-#include "intel_gpu/primitives/arg_max_min.hpp"
-#include "intel_gpu/primitives/assign.hpp"
-#include "intel_gpu/primitives/average_unpooling.hpp"
-#include "intel_gpu/primitives/batch_to_space.hpp"
-#include "intel_gpu/primitives/binary_convolution.hpp"
-#include "intel_gpu/primitives/border.hpp"
-#include "intel_gpu/primitives/broadcast.hpp"
-#include "intel_gpu/primitives/bucketize.hpp"
-#include "intel_gpu/primitives/concatenation.hpp"
-#include "intel_gpu/primitives/condition.hpp"
-#include "intel_gpu/primitives/convert_color.hpp"
-#include "intel_gpu/primitives/convolution.hpp"
-#include "intel_gpu/primitives/crop.hpp"
-#include "intel_gpu/primitives/ctc_greedy_decoder.hpp"
-#include "intel_gpu/primitives/ctc_loss.hpp"
-#include "intel_gpu/primitives/cum_sum.hpp"
-#include "intel_gpu/primitives/custom_gpu_primitive.hpp"
-#include "intel_gpu/primitives/data.hpp"
-#include "intel_gpu/primitives/deconvolution.hpp"
-#include "intel_gpu/primitives/depth_to_space.hpp"
-#include "intel_gpu/primitives/detection_output.hpp"
-#include "intel_gpu/primitives/dft.hpp"
-#include "intel_gpu/primitives/eltwise.hpp"
-#include "intel_gpu/primitives/embedding_bag.hpp"
-#include "intel_gpu/primitives/experimental_detectron_detection_output.hpp"
-#include "intel_gpu/primitives/experimental_detectron_generate_proposals_single_image.hpp"
-#include "intel_gpu/primitives/experimental_detectron_prior_grid_generator.hpp"
-#include "intel_gpu/primitives/experimental_detectron_roi_feature_extractor.hpp"
-#include "intel_gpu/primitives/experimental_detectron_topk_rois.hpp"
-#include "intel_gpu/primitives/extract_image_patches.hpp"
-#include "intel_gpu/primitives/eye.hpp"
-#include "intel_gpu/primitives/fully_connected.hpp"
-#include "intel_gpu/primitives/gather_elements.hpp"
-#include "intel_gpu/primitives/gather_nd.hpp"
-#include "intel_gpu/primitives/gather_tree.hpp"
-#include "intel_gpu/primitives/gather.hpp"
-#include "intel_gpu/primitives/gemm.hpp"
-#include "intel_gpu/primitives/generate_proposals.hpp"
-#include "intel_gpu/primitives/grn.hpp"
-#include "intel_gpu/primitives/grn.hpp"
-#include "intel_gpu/primitives/input_layout.hpp"
-#include "intel_gpu/primitives/loop.hpp"
-#include "intel_gpu/primitives/lrn.hpp"
-#include "intel_gpu/primitives/lstm_dynamic_input.hpp"
-#include "intel_gpu/primitives/lstm_dynamic_timeloop.hpp"
-#include "intel_gpu/primitives/lstm_dynamic.hpp"
-#include "intel_gpu/primitives/lstm.hpp"
-#include "intel_gpu/primitives/multiclass_nms.hpp"
-#include "intel_gpu/primitives/mutable_data.hpp"
-#include "intel_gpu/primitives/mvn.hpp"
-#include "intel_gpu/primitives/non_max_suppression.hpp"
-#include "intel_gpu/primitives/non_zero.hpp"
-#include "intel_gpu/primitives/normalize.hpp"
-#include "intel_gpu/primitives/one_hot.hpp"
-#include "intel_gpu/primitives/permute.hpp"
-#include "intel_gpu/primitives/pooling.hpp"
-#include "intel_gpu/primitives/prior_box.hpp"
-#include "intel_gpu/primitives/proposal.hpp"
-#include "intel_gpu/primitives/pyramid_roi_align.hpp"
-#include "intel_gpu/primitives/quantize.hpp"
-#include "intel_gpu/primitives/random_uniform.hpp"
-#include "intel_gpu/primitives/range.hpp"
-#include "intel_gpu/primitives/read_value.hpp"
-#include "intel_gpu/primitives/reduce.hpp"
-#include "intel_gpu/primitives/region_yolo.hpp"
-#include "intel_gpu/primitives/reorder.hpp"
-#include "intel_gpu/primitives/reorg_yolo.hpp"
-#include "intel_gpu/primitives/resample.hpp"
-#include "intel_gpu/primitives/reshape.hpp"
-#include "intel_gpu/primitives/reverse_sequence.hpp"
-#include "intel_gpu/primitives/reverse.hpp"
-#include "intel_gpu/primitives/roi_align.hpp"
-#include "intel_gpu/primitives/roi_pooling.hpp"
-#include "intel_gpu/primitives/roll.hpp"
-#include "intel_gpu/primitives/scatter_elements_update.hpp"
-#include "intel_gpu/primitives/scatter_nd_update.hpp"
-#include "intel_gpu/primitives/scatter_update.hpp"
-#include "intel_gpu/primitives/select.hpp"
-#include "intel_gpu/primitives/shape_of.hpp"
-#include "intel_gpu/primitives/shuffle_channels.hpp"
-#include "intel_gpu/primitives/slice.hpp"
-#include "intel_gpu/primitives/softmax.hpp"
-#include "intel_gpu/primitives/space_to_batch.hpp"
-#include "intel_gpu/primitives/space_to_depth.hpp"
-#include "intel_gpu/primitives/split.hpp"
-#include "intel_gpu/primitives/strided_slice.hpp"
-#include "intel_gpu/primitives/tile.hpp"
-
-cldnn::primitive_type_id cldnn::get_type_id(std::string type_str) {
-    static std::unordered_map<std::string, primitive_type_id> primitive_inst_types = {
-        {"activation", cldnn::activation::type_id()},
-        {"adaptive_pooling", cldnn::adaptive_pooling::type_id()},
-        {"arg_max_min", cldnn::arg_max_min::type_id()},
-        {"assign", cldnn::assign::type_id()},
-        {"average_unpooling", cldnn::average_unpooling::type_id()},
-        {"binary_convolution", cldnn::binary_convolution::type_id()},
-        {"border", cldnn::border::type_id()},
-        {"broadcast", cldnn::broadcast::type_id()},
-        {"bucketize", cldnn::bucketize::type_id()},
-        {"batch_to_space", cldnn::batch_to_space::type_id()},
-        {"space_to_batch", cldnn::space_to_batch::type_id()},
-        {"concatenation", cldnn::concatenation::type_id()},
-        {"condition", cldnn::condition::type_id()},
-        {"convert_color", cldnn::convert_color::type_id()},
-        {"convolution", cldnn::convolution::type_id()},
-        {"count_nonzero", cldnn::count_nonzero::type_id()},
-        {"crop", cldnn::crop::type_id()},
-        {"ctc_greedy_decoder", cldnn::ctc_greedy_decoder::type_id()},
-        {"ctc_loss", cldnn::ctc_loss::type_id()},
-        {"cum_sum", cldnn::cum_sum::type_id()},
-        {"custom_gpu_primitive", cldnn::custom_gpu_primitive::type_id()},
-        {"data", cldnn::data::type_id()},
-        {"deconvolution", cldnn::deconvolution::type_id()},
-        {"deformable_conv", cldnn::deformable_conv::type_id()},
-        {"deformable_interp", cldnn::deformable_interp::type_id()},
-        {"depth_to_space", cldnn::depth_to_space::type_id()},
-        {"detection_output", cldnn::detection_output::type_id()},
-        {"dft", cldnn::dft::type_id()},
-        {"eltwise", cldnn::eltwise::type_id()},
-        {"embedding_bag", cldnn::embedding_bag::type_id()},
-        {"experimental_detectron_detection_output", cldnn::experimental_detectron_detection_output::type_id()},
-        {"experimental_detectron_generate_proposals_single_image", cldnn::experimental_detectron_generate_proposals_single_image::type_id()},
-        {"experimental_detectron_prior_grid_generator", cldnn::experimental_detectron_prior_grid_generator::type_id()},
-        {"experimental_detectron_roi_feature_extractor", cldnn::experimental_detectron_roi_feature_extractor::type_id()},
-        {"experimental_detectron_topk_rois", cldnn::experimental_detectron_topk_rois::type_id()},
-        {"extract_image_patches", cldnn::extract_image_patches::type_id()},
-        {"eye", cldnn::eye::type_id()},
-        {"fully_connected", cldnn::fully_connected::type_id()},
-        {"gather", cldnn::gather::type_id()},
-        {"gather_elements", cldnn::gather_elements::type_id()},
-        {"gather_nd", cldnn::gather_nd::type_id()},
-        {"gather_nonzero", cldnn::gather_nonzero::type_id()},
-        {"gather_tree", cldnn::gather_tree::type_id()},
-        {"gemm", cldnn::gemm::type_id()},
-        {"generate_proposals", cldnn::generate_proposals::type_id()},
-        {"generic_layer", cldnn::generic_layer::type_id()},
-        {"grn", cldnn::grn::type_id()},
-        {"input_layout", cldnn::input_layout::type_id()},
-        {"loop", cldnn::loop::type_id()},
-        {"lrn", cldnn::lrn::type_id()},
-        {"lstm", cldnn::lstm::type_id()},
-        {"lstm_dynamic", cldnn::lstm_dynamic::type_id()},
-        {"lstm_dynamic_input", cldnn::lstm_dynamic_input::type_id()},
-        {"lstm_dynamic_timeloop", cldnn::lstm_dynamic_timeloop::type_id()},
-        {"lstm_elt", cldnn::lstm_elt::type_id()},
-        {"lstm_gemm", cldnn::lstm_gemm::type_id()},
-        {"multiclass_nms", cldnn::multiclass_nms::type_id()},
-        {"mutable_data", cldnn::mutable_data::type_id()},
-        {"mvn", cldnn::mvn::type_id()},
-        {"non_max_suppression", cldnn::non_max_suppression::type_id()},
-        {"normalize", cldnn::normalize::type_id()},
-        {"one_hot", cldnn::one_hot::type_id()},
-        {"permute", cldnn::permute::type_id()},
-        {"pooling", cldnn::pooling::type_id()},
-        {"prior_box", cldnn::prior_box::type_id()},
-        {"proposal", cldnn::proposal::type_id()},
-        {"pyramid_roi_align", cldnn::pyramid_roi_align::type_id()},
-        {"quantize", cldnn::quantize::type_id()},
-        {"random_uniform", cldnn::random_uniform::type_id()},
-        {"range", cldnn::range::type_id()},
-        {"read_value", cldnn::read_value::type_id()},
-        {"reduce", cldnn::reduce::type_id()},
-        {"region_yolo", cldnn::region_yolo::type_id()},
-        {"reorder", cldnn::reorder::type_id()},
-        {"reorg_yolo", cldnn::reorg_yolo::type_id()},
-        {"resample", cldnn::resample::type_id()},
-        {"reshape", cldnn::reshape::type_id()},
-        {"reverse", cldnn::reverse::type_id()},
-        {"reverse_sequence", cldnn::reverse_sequence::type_id()},
-        {"roi_align", cldnn::roi_align::type_id()},
-        {"roi_pooling", cldnn::roi_pooling::type_id()},
-        {"roll", cldnn::roll::type_id()},
-        {"scatter_elements_update", cldnn::scatter_elements_update::type_id()},
-        {"scatter_nd_update", cldnn::scatter_nd_update::type_id()},
-        {"scatter_update", cldnn::scatter_update::type_id()},
-        {"select", cldnn::select::type_id()},
-        {"shape_of", cldnn::shape_of::type_id()},
-        {"shuffle_channels", cldnn::shuffle_channels::type_id()},
-        {"slice", cldnn::slice::type_id()},
-        {"softmax", cldnn::softmax::type_id()},
-        {"space_to_depth", cldnn::space_to_depth::type_id()},
-        {"split", cldnn::split::type_id()},
-        {"strided_slice", cldnn::strided_slice::type_id()},
-        {"tile", cldnn::tile::type_id()},
-    };
-
-    return primitive_inst_types[type_str];
-}
\ No newline at end of file
diff --git a/src/plugins/intel_gpu/src/graph/grid_sample.cpp b/src/plugins/intel_gpu/src/graph/grid_sample.cpp
index 57f7052f71ce46..9fc3575d9395e1 100644
--- a/src/plugins/intel_gpu/src/graph/grid_sample.cpp
+++ b/src/plugins/intel_gpu/src/graph/grid_sample.cpp
@@ -9,11 +9,7 @@
 #include "primitive_type_base.h"
 
 namespace cldnn {
-
-primitive_type_id grid_sample::type_id() {
-    static primitive_type_base<grid_sample> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(grid_sample)
 
 layout grid_sample_inst::calc_output_layout(const grid_sample_node& node, const kernel_impl_params& impl_param) {
     const auto data_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/grn.cpp b/src/plugins/intel_gpu/src/graph/grn.cpp
index 919cea62e126f0..e68f17554516ad 100644
--- a/src/plugins/intel_gpu/src/graph/grn.cpp
+++ b/src/plugins/intel_gpu/src/graph/grn.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id grn::type_id() {
-    static primitive_type_base<grn> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(grn)
 
 layout grn_inst::calc_output_layout(grn_node const& node, kernel_impl_params const& impl_param) {
     auto input_node_layout = impl_param.get_non_padded_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp b/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
index 7ca3bb697f87b8..06b59924340579 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
@@ -13,6 +13,8 @@ namespace cldnn {
 namespace common {
 
 struct condition_impl : typed_primitive_impl<condition> {
+    DECLARE_OBJECT_TYPE_SERIALIZATION
+
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<condition_impl>(*this);
     }
@@ -135,3 +137,5 @@ attach_condition_common::attach_condition_common() {
 }  // namespace detail
 }  // namespace common
 }  // namespace cldnn
+
+ASSIGN_TYPE_NAME(cldnn::common::condition_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp b/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp
index 577a5d72c69ec5..a2d7ce84474d89 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp
@@ -14,6 +14,8 @@
 namespace cldnn {
 namespace common {
 struct loop_impl : typed_primitive_impl<loop> {
+    DECLARE_OBJECT_TYPE_SERIALIZATION
+
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<loop_impl>(*this);
     }
@@ -210,3 +212,5 @@ attach_loop_common::attach_loop_common() {
 
 }  // namespace common
 }  // namespace cldnn
+
+ASSIGN_TYPE_NAME(cldnn::common::loop_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp b/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp
index c0abd5377aa03d..b7d52ab938c55e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp
@@ -8,7 +8,7 @@
 #include "input_layout_inst.h"
 #include "impls/implementation_map.hpp"
 #include "register.hpp"
-#include "serialization/binary_buffer.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 #include <vector>
 
 namespace cldnn {
@@ -77,4 +77,4 @@ attach_prior_box_common::attach_prior_box_common() {
 }  // namespace common
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::common::wait_for_events_impl, cldnn::object_type::WAIT_FOR_EVENTS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::common::wait_for_events_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
index 6b3fcc3c545c85..1c824b12127ebe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
@@ -56,4 +56,4 @@ attach_assign_impl::attach_assign_impl() {
 }  // namespace cpu
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::assign_impl, cldnn::object_type::ASSIGN_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::assign_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
index 0f9d3328ab695a..b11ffaf63edc14 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/detection_output.cpp
@@ -874,4 +874,4 @@ attach_detection_output_impl::attach_detection_output_impl() {
 }  // namespace cpu
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::detection_output_impl, cldnn::object_type::DETECTION_OUTPUT_IMPL_CPU)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::detection_output_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/non_max_suppression.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/non_max_suppression.cpp
index 50eb5bb4a343a7..16b3ee28d8b3f2 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/non_max_suppression.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/non_max_suppression.cpp
@@ -435,4 +435,4 @@ attach_non_max_suppression_impl::attach_non_max_suppression_impl() {
 }  // namespace cpu
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::non_max_suppression_impl, cldnn::object_type::NON_MAX_SUPPRESSION_IMPL_CPU)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::non_max_suppression_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
index c8616303daf138..b2283ad7d4fd6b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
@@ -461,4 +461,4 @@ attach_proposal_impl::attach_proposal_impl() {
 }  // namespace cpu
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::proposal_impl, cldnn::object_type::PROPOSAL_IMPL_CPU)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::proposal_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp b/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
index 88ef5d3525d519..4b0de7dec4a08b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/read_value.cpp
@@ -56,4 +56,4 @@ attach_read_value_impl::attach_read_value_impl() {
 }  // namespace cpu
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::read_value_impl, cldnn::object_type::READ_VALUE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::cpu::read_value_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
index 59d02527995737..3492c1f93dc36c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
@@ -156,4 +156,4 @@ attach_activation_impl::attach_activation_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::activation_impl, cldnn::object_type::ACTIVATION_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::activation_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/adaptive_pooling.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/adaptive_pooling.cpp
index cc06fada7517b0..66515e886e2ffc 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/adaptive_pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/adaptive_pooling.cpp
@@ -92,4 +92,4 @@ attach_adaptive_pooling_impl::attach_adaptive_pooling_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::adaptive_pooling_impl, cldnn::object_type::ADAPTIVE_POOLING_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::adaptive_pooling_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
index f8c90fafd406ca..93d8b9c70fa253 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/arg_max_min.cpp
@@ -126,4 +126,4 @@ attach_arg_max_min_impl::attach_arg_max_min_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::arg_max_min_impl, cldnn::object_type::ARG_MAX_MIN_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::arg_max_min_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/average_unpooling.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/average_unpooling.cpp
index 9dedd0c78e430a..6f0c47509d8675 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/average_unpooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/average_unpooling.cpp
@@ -69,4 +69,4 @@ attach_average_unpooling_impl::attach_average_unpooling_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::average_unpooling_impl, cldnn::object_type::AVERAGE_UNPOOLING_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::average_unpooling_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/batch_to_space.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/batch_to_space.cpp
index 328f4cfd2d1dae..c0433191e0b40a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/batch_to_space.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/batch_to_space.cpp
@@ -68,4 +68,4 @@ attach_batch_to_space_impl::attach_batch_to_space_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::batch_to_space_impl, cldnn::object_type::BATCH_TO_SPACE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::batch_to_space_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/binary_convolution.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/binary_convolution.cpp
index a56cb040e537c1..d0f7e6a9851f30 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/binary_convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/binary_convolution.cpp
@@ -154,4 +154,4 @@ attach_binary_convolution_impl::attach_binary_convolution_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::binary_convolution_impl, cldnn::object_type::BINARY_CONVOLUTION_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::binary_convolution_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
index 127f274637e461..7aabf8352d04bd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
@@ -166,4 +166,4 @@ attach_border_impl::attach_border_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::border_impl, cldnn::object_type::BORDER_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::border_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
index 1493a56cbffb83..b86bbabbd221a9 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
@@ -168,4 +168,4 @@ attach_broadcast_impl::attach_broadcast_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::broadcast_impl, cldnn::object_type::BROADCAST_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::broadcast_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp
index d59eec4cd9cdfe..f6ee0585c08b0c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp
@@ -70,4 +70,4 @@ attach_bucketize_impl::attach_bucketize_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::bucketize_impl, cldnn::object_type::BUCKETIZE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::bucketize_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
index 20727257594a18..4d73c498f9d178 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
@@ -201,4 +201,4 @@ attach_concatenation_impl::attach_concatenation_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::concatenation_impl, cldnn::object_type::CONCATENATION_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::concatenation_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/convert_color.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/convert_color.cpp
index 84d9d396f691dd..8502538e192f65 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/convert_color.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/convert_color.cpp
@@ -70,4 +70,4 @@ attach_convert_color_impl::attach_convert_color_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::convert_color_impl, cldnn::object_type::CONVERT_COLOR_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::convert_color_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
index 44062954ca4ea6..07c5d32c2e5f1c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
@@ -281,4 +281,4 @@ attach_convolution_impl::attach_convolution_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::convolution_impl, cldnn::object_type::CONVOLUTION_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::convolution_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
index 797c6de6d79014..7dd28fc57c5b7c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
@@ -157,4 +157,4 @@ attach_crop_impl::attach_crop_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::crop_impl, cldnn::object_type::CROP_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::crop_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_greedy_decoder.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_greedy_decoder.cpp
index 5071f453db46e5..e52e5abb7cf0ad 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_greedy_decoder.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_greedy_decoder.cpp
@@ -62,4 +62,4 @@ attach_ctc_greedy_decoder_impl::attach_ctc_greedy_decoder_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::ctc_greedy_decoder_impl, cldnn::object_type::CTC_GREEDY_DECODER_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::ctc_greedy_decoder_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_loss.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_loss.cpp
index 7d228726a24556..2635c327b72350 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_loss.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/ctc_loss.cpp
@@ -57,4 +57,4 @@ attach_ctc_loss_impl::attach_ctc_loss_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::ctc_loss_impl, cldnn::object_type::CTC_LOSS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::ctc_loss_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
index 48ec50b07c39be..24b00fd7f6683c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/cum_sum.cpp
@@ -96,4 +96,4 @@ attach_cum_sum_impl::attach_cum_sum_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::cum_sum_impl, cldnn::object_type::CUM_SUM_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::cum_sum_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
index 5272f6bbff6329..145a4189e82a3a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/custom_primitive.cpp
@@ -78,13 +78,17 @@ struct custom_gpu_primitive_impl : typed_primitive_impl<custom_gpu_primitive> {
             args.inputs.push_back(dep->output_memory_ptr());
         }
         args.outputs = { instance.output_memory_ptr() };
-        return stream.enqueue_kernel(*_kernels.front(), cl_kernel.get()->params, args, events, instance.node->is_output());
+        return stream.enqueue_kernel(*_kernels.front(), cl_kernel.get()->params, args, events, instance.is_output());
     }
 
-    std::vector<std::string> get_kernel_ids() override {
+    std::vector<std::string> get_kernel_ids() const override {
         return {_kernel_id};
     }
 
+    std::vector<kernel::ptr> get_kernels() const override {
+        return _kernels;
+    }
+
     void save(BinaryOutputBuffer& ob) const override {
         ob << *cl_kernel;
         ob << _kernel_id;
@@ -258,4 +262,4 @@ attach_custom_gpu_primitive_impl::attach_custom_gpu_primitive_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::custom_gpu_primitive_impl, cldnn::object_type::CUSTOM_GPU_PRIMITIVE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::custom_gpu_primitive_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp
index 67247ade7547b3..333c07caeac795 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp
@@ -167,4 +167,4 @@ attach_deconvolution_impl::attach_deconvolution_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deconvolution_impl, cldnn::object_type::DECONVOLUTION_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deconvolution_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/deformable_convolution.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/deformable_convolution.cpp
index 9aca5783f73951..f0cacef75c01de 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/deformable_convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/deformable_convolution.cpp
@@ -192,5 +192,5 @@ attach_deformable_interp_impl::attach_deformable_interp_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deformable_conv_impl, cldnn::object_type::DEFORMABLE_CONV_IMPL)
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deformable_interp_impl, cldnn::object_type::DEFORMABLE_INTERP_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deformable_conv_impl)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::deformable_interp_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/depth_to_space.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/depth_to_space.cpp
index bc085b15d5474e..f90e2c8257fabe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/depth_to_space.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/depth_to_space.cpp
@@ -64,4 +64,4 @@ attach_depth_to_space_impl::attach_depth_to_space_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::depth_to_space_impl, cldnn::object_type::DEPTH_TO_SPACE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::depth_to_space_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/detection_output.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/detection_output.cpp
index 5fe817b0481069..ae35a2f7bdfa2f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/detection_output.cpp
@@ -92,4 +92,4 @@ attach_detection_output_impl::attach_detection_output_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::detection_output_impl, cldnn::object_type::DETECTION_OUTPUT_IMPL_OCL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::detection_output_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp
index 958fd837d79985..387e78d092c1ff 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp
@@ -105,4 +105,4 @@ attach_dft_impl::attach_dft_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::dft_impl, cldnn::object_type::DFT_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::dft_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
index 08fa31cd8f8cfe..6824e06855299c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
@@ -278,4 +278,4 @@ attach_eltwise_impl::attach_eltwise_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::eltwise_impl, cldnn::object_type::ELTWISE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::eltwise_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/embedding_bag.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/embedding_bag.cpp
index 86020c16de31b3..5ff4cb47a2db62 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/embedding_bag.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/embedding_bag.cpp
@@ -69,4 +69,4 @@ attach_embedding_bag_impl::attach_embedding_bag_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::embedding_bag_impl, cldnn::object_type::EMBEDDING_BAG_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::embedding_bag_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_detection_output.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_detection_output.cpp
index 4ccc17de90ac41..315e3e9b5491d2 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_detection_output.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_detection_output.cpp
@@ -77,5 +77,4 @@ attach_experimental_detectron_detection_output_impl::attach_experimental_detectr
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_detection_output_impl,
-                             cldnn::object_type::ACTIVATION_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_detection_output_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_generate_proposals_single_image.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_generate_proposals_single_image.cpp
index c940038553f646..fca543796a7c87 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_generate_proposals_single_image.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_generate_proposals_single_image.cpp
@@ -83,5 +83,4 @@ attach_experimental_detectron_generate_proposals_single_image_impl::attach_exper
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_generate_proposals_single_image_impl,
-                             cldnn::object_type::EXPERIMENTAL_DETECTRON_GENERATE_PROPOSALS_SINGLE_IMAGE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_generate_proposals_single_image_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_prior_grid_generator.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_prior_grid_generator.cpp
index 532b6bf056df98..1c989a3f234b75 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_prior_grid_generator.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_prior_grid_generator.cpp
@@ -64,5 +64,4 @@ attach_experimental_detectron_prior_grid_generator_impl::attach_experimental_det
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_prior_grid_generator_impl,
-                             cldnn::object_type::EXPERIMENTAL_DETECTRON_PRIOR_GRID_GENERATOR_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_prior_grid_generator_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_roi_feature_extractor.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_roi_feature_extractor.cpp
index 988f81159dd440..948796a1fddc70 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_roi_feature_extractor.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_roi_feature_extractor.cpp
@@ -82,5 +82,4 @@ attach_experimental_detectron_roi_feature_extractor_impl::attach_experimental_de
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_roi_feature_extractor_impl,
-                             cldnn::object_type::EXPERIMENTAL_DETECTRON_ROI_FEATURE_EXTRACTOR_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_roi_feature_extractor_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_topk_rois.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_topk_rois.cpp
index 6febbbfb3f5361..19c41a69190aa0 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_topk_rois.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/experimental_detectron_topk_rois.cpp
@@ -58,5 +58,4 @@ attach_experimental_detectron_topk_rois_impl::attach_experimental_detectron_topk
 } // namespace ocl
 } // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_topk_rois_impl,
-                             cldnn::object_type::EXPERIMENTAL_DETECTRON_TOPK_ROIS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::experimental_detectron_topk_rois_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/extract_image_patches.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/extract_image_patches.cpp
index 199e7775f96862..0c65d3e75f4b7a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/extract_image_patches.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/extract_image_patches.cpp
@@ -57,4 +57,4 @@ attach_extract_image_patches_impl::attach_extract_image_patches_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::extract_image_patches_impl, cldnn::object_type::EXTRACT_IMAGE_PATCHES_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::extract_image_patches_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/eye.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/eye.cpp
index 10e3514d46d8c3..6c3470a8e51ebe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/eye.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/eye.cpp
@@ -74,4 +74,4 @@ attach_eye_impl::attach_eye_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::eye_impl, cldnn::object_type::EYE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::eye_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
index f88969ebf8c80e..fb21537282be1d 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/fully_connected.cpp
@@ -151,4 +151,4 @@ attach_fully_connected_impl::attach_fully_connected_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::fully_connected_impl, cldnn::object_type::FULLY_CONNECTED_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::fully_connected_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
index d1efccb669952d..fe47acad1990cd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
@@ -211,4 +211,4 @@ attach_gather_impl::attach_gather_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_impl, cldnn::object_type::GATHER_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
index e91bade0711b83..3812ea48c060f1 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_elements.cpp
@@ -93,4 +93,4 @@ attach_gather_elements_impl::attach_gather_elements_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_elements_impl, cldnn::object_type::GATHER_ELEMENTS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_elements_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
index a0a88aff702e92..c2f840951c9163 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_nd.cpp
@@ -60,4 +60,4 @@ attach_gather_nd_impl::attach_gather_nd_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_nd_impl, cldnn::object_type::GATHER_ND_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_nd_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_tree.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_tree.cpp
index 7f781e7ccd5296..887d4cb50476a6 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather_tree.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather_tree.cpp
@@ -63,4 +63,4 @@ attach_gather_tree_impl::attach_gather_tree_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_tree_impl, cldnn::object_type::GATHER_TREE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_tree_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
index 5afd4fe0bf6ea2..1a7d863e934f6e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
@@ -165,4 +165,4 @@ attach_gemm_impl::attach_gemm_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gemm_impl, cldnn::object_type::GEMM_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gemm_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/generate_proposals.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/generate_proposals.cpp
index 2b0993bc680de5..0d0bc5c3b3f0fe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/generate_proposals.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/generate_proposals.cpp
@@ -78,4 +78,4 @@ namespace detail {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::generate_proposals_impl, cldnn::object_type::GENERATE_PROPOSALS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::generate_proposals_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/generic_layer.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/generic_layer.cpp
index 81ae1850b332f1..bf1e456750c5e2 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/generic_layer.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/generic_layer.cpp
@@ -86,6 +86,7 @@ struct generic_layer_impl : typed_primitive_impl<generic_layer> {
 // TODO: move this file to cpu folder and add a new traget to 'cldnn::engine_types'
 struct generic_layer_cpu : typed_primitive_impl<generic_layer> {
     const generic_layer_node& outer;
+    DECLARE_OBJECT_TYPE_SERIALIZATION
 
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<generic_layer_cpu>(*this);
@@ -136,4 +137,5 @@ attach_generic_layer_impl::attach_generic_layer_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::generic_layer_impl, cldnn::object_type::GENERIC_LAYER_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::generic_layer_impl)
+ASSIGN_TYPE_NAME(cldnn::ocl::generic_layer_cpu)
\ No newline at end of file
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/grid_sample.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/grid_sample.cpp
index 15a5f34e8e3d69..0063a1c6003aa9 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/grid_sample.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/grid_sample.cpp
@@ -87,4 +87,4 @@ attach_grid_sample_impl::attach_grid_sample_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::grid_sample_impl, cldnn::object_type::GRID_SAMPLE_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::grid_sample_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp
index 9dd877c5d8d12b..9eece30b14332a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp
@@ -54,4 +54,4 @@ attach_grn_impl::attach_grn_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::grn_impl, cldnn::object_type::GRN_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::grn_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp
index d13e574d213166..79517b7f30878c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp
@@ -93,4 +93,4 @@ attach_lrn_impl::attach_lrn_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lrn_impl, cldnn::object_type::LRN_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lrn_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_input.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_input.cpp
index b2b848c729e749..8f6548931bd9b6 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_input.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_input.cpp
@@ -78,4 +78,4 @@ attach_lstm_dynamic_input_impl::attach_lstm_dynamic_input_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_dynamic_input_impl, cldnn::object_type::LSTM_DYNAMIC_INPUT_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_dynamic_input_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_timeloop.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_timeloop.cpp
index ce98279b24bfad..e064b05b2c59f8 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_timeloop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_dynamic_timeloop.cpp
@@ -100,4 +100,4 @@ attach_lstm_dynamic_timeloop_impl::attach_lstm_dynamic_timeloop_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_dynamic_timeloop_impl, cldnn::object_type::LSTM_DYNAMIC_TIMELOOP_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_dynamic_timeloop_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_elt.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_elt.cpp
index 9abca882abde19..0d1a39d13eac8e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_elt.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_elt.cpp
@@ -103,4 +103,4 @@ attach_lstm_elt_impl::attach_lstm_elt_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_elt_impl, cldnn::object_type::LSTM_ELT_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_elt_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_gemm.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_gemm.cpp
index 942dcdef6fe6cc..4c2c9da44a9715 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lstm_gemm.cpp
@@ -104,4 +104,4 @@ attach_lstm_gemm_impl::attach_lstm_gemm_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_gemm_impl, cldnn::object_type::LSTM_GEMM_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::lstm_gemm_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/matrix_nms.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/matrix_nms.cpp
index 2cb99dce385092..9509564cdf412f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/matrix_nms.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/matrix_nms.cpp
@@ -43,6 +43,8 @@ struct matrix_nms_impl : typed_primitive_impl_ocl<matrix_nms> {
     using kernel_selector_t = kernel_selector::matrix_nms_kernel_selector;
     using kernel_params_t = std::pair<kernel_selector::matrix_nms_params, kernel_selector::matrix_nms_optional_params>;
 
+    DECLARE_OBJECT_TYPE_SERIALIZATION
+
     std::unique_ptr<primitive_impl> clone() const override {
         return make_unique<matrix_nms_impl>(*this);
     }
@@ -106,3 +108,5 @@ attach_matrix_nms_impl::attach_matrix_nms_impl() {
 }  // namespace detail
 }  // namespace ocl
 }  // namespace cldnn
+
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::matrix_nms_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/multiclass_nms.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/multiclass_nms.cpp
index 271c3c587137d0..6d0c51dc00c388 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/multiclass_nms.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/multiclass_nms.cpp
@@ -116,4 +116,4 @@ attach_multiclass_nms_impl::attach_multiclass_nms_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::multiclass_nms_impl, cldnn::object_type::MULTICLASS_NMS_IMPL)
\ No newline at end of file
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::multiclass_nms_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/mutable_data.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/mutable_data.cpp
index 86600cae2ab2a3..1cc650329144cf 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/mutable_data.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/mutable_data.cpp
@@ -35,4 +35,4 @@ attach_mutable_data_impl::attach_mutable_data_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::mutable_data_impl, cldnn::object_type::MUTABLE_DATA_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::mutable_data_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
index 1b84b90d9199e6..2c739a0ac441c3 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
@@ -100,4 +100,4 @@ attach_mvn_impl::attach_mvn_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::mvn_impl, cldnn::object_type::MVN_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::mvn_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/non_max_suppression.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/non_max_suppression.cpp
index c9edd4524323b6..96b89537a82865 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/non_max_suppression.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/non_max_suppression.cpp
@@ -213,4 +213,4 @@ attach_non_max_suppression_impl::attach_non_max_suppression_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::non_max_suppression_impl, cldnn::object_type::NON_MAX_SUPPRESSION_IMPL_OCL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::non_max_suppression_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
index 6993bca663d2bc..78a982a1a53a89 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/non_zero.cpp
@@ -108,5 +108,5 @@ attach_gather_nonzero_impl::attach_gather_nonzero_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::count_nonzero_impl, cldnn::object_type::COUNT_NONZERO_IMPL)
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_nonzero_impl, cldnn::object_type::GATHER_NONZERO_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::count_nonzero_impl)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::gather_nonzero_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp
index ecb2d908052428..aac624dde1e164 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp
@@ -77,4 +77,4 @@ attach_normalize_impl::attach_normalize_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::normalize_impl, cldnn::object_type::NORMALIZE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::normalize_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/one_hot.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/one_hot.cpp
index 7e9ad4c51f5b35..d1c33c4c72eae8 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/one_hot.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/one_hot.cpp
@@ -66,4 +66,4 @@ attach_one_hot_impl::attach_one_hot_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::one_hot_impl, cldnn::object_type::ONE_HOT_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::one_hot_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
index dff87acdbcd164..e69507eaf42401 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
@@ -82,4 +82,4 @@ attach_permute_impl::attach_permute_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::permute_impl, cldnn::object_type::PERMUTE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::permute_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp
index 51a4f030f54423..dffc9b5079b75c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp
@@ -206,4 +206,4 @@ attach_pooling_impl::attach_pooling_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::pooling_impl, cldnn::object_type::POOLING_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::pooling_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp b/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
index bde5d9c9445d19..1a78aedf768135 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
@@ -11,12 +11,12 @@
 #include "intel_gpu/runtime/error_handler.hpp"
 #include "kernel_selector_helper.h"
 #include "intel_gpu/graph/network.hpp"
-#include "serialization/binary_buffer.hpp"
-#include "serialization/cl_kernel_data_serializer.hpp"
-#include "serialization/helpers.hpp"
-#include "serialization/set_serializer.hpp"
-#include "serialization/string_serializer.hpp"
-#include "serialization/vector_serializer.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
+#include "intel_gpu/graph/serialization/cl_kernel_data_serializer.hpp"
+#include "intel_gpu/graph/serialization/helpers.hpp"
+#include "intel_gpu/graph/serialization/set_serializer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
+#include "intel_gpu/graph/serialization/vector_serializer.hpp"
 #include "register.hpp"
 #include <vector>
 #include <list>
@@ -67,6 +67,10 @@ struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
 
     bool is_cpu() const override { return false; }
 
+    // Cache blob format:
+    //     [ kernel_selector::kernel_data ]
+    //     [ kernel_id ]
+    //     [ kernel_arguments ]
     void save(BinaryOutputBuffer& ob) const override {
         ob << make_data(&_kernel_data.internalBufferDataType, sizeof(kernel_selector::Datatype));
         ob << _kernel_data.internalBufferSizes;
@@ -177,10 +181,14 @@ struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
         }
     }
 
-    std::vector<std::string> get_kernel_ids() override {
+    std::vector<std::string> get_kernel_ids() const override {
         return _kernel_ids;
     }
 
+    std::vector<kernel::ptr> get_kernels() const override {
+        return _kernels;
+    }
+
     std::vector<layout> get_internal_buffer_layouts_impl() const override {
         if (_kernel_data.internalBufferSizes.empty())
             return {};
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/prior_box.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/prior_box.cpp
index d17925b279865a..7c6e911309aafc 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/prior_box.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/prior_box.cpp
@@ -99,4 +99,4 @@ attach_prior_box_impl::attach_prior_box_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::prior_box_impl, cldnn::object_type::PRIOR_BOX_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::prior_box_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/pyramid_roi_align.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/pyramid_roi_align.cpp
index 96b0bff9c62e1a..146f006e506fb2 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/pyramid_roi_align.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/pyramid_roi_align.cpp
@@ -73,4 +73,4 @@ attach_pyramid_roi_align_impl::attach_pyramid_roi_align_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::pyramid_roi_align_impl, cldnn::object_type::PYRAMID_ROI_ALIGN_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::pyramid_roi_align_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
index e8466e7647e27a..b2ad4926dbb6c7 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
@@ -203,4 +203,4 @@ attach_quantize_impl::attach_quantize_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::quantize_impl, cldnn::object_type::QUANTIZE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::quantize_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/random_uniform.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/random_uniform.cpp
index a2f8e4ee2e1f75..53cbdfbfa67594 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/random_uniform.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/random_uniform.cpp
@@ -61,4 +61,4 @@ attach_random_uniform_impl::attach_random_uniform_impl() {
 } // namespace ocl
 } // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::random_uniform_impl, cldnn::object_type::RANDOM_UNIFORM_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::random_uniform_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
index 417e92f283907f..c2c1d2bc797fdb 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
@@ -56,4 +56,4 @@ attach_range_impl::attach_range_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::range_impl, cldnn::object_type::RANGE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::range_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
index b3a2d889f883d5..cf4aa3892a3bb7 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
@@ -137,4 +137,4 @@ attach_reduce_impl::attach_reduce_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reduce_impl, cldnn::object_type::REDUCE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reduce_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/region_yolo.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/region_yolo.cpp
index 129ccb89a6d862..267902044ef921 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/region_yolo.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/region_yolo.cpp
@@ -59,4 +59,4 @@ attach_region_yolo_impl::attach_region_yolo_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::region_yolo_impl, cldnn::object_type::REGION_YOLO_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::region_yolo_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
index 7c97252703f5b9..3eb1ffe8896b6c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
@@ -150,4 +150,4 @@ attach_reorder_impl::attach_reorder_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reorder_impl, cldnn::object_type::REORDER_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reorder_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reorg_yolo.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reorg_yolo.cpp
index 53ca76294cc481..6f2e50ff59703a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reorg_yolo.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reorg_yolo.cpp
@@ -57,4 +57,4 @@ attach_reorg_yolo_impl::attach_reorg_yolo_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reorg_yolo_impl, cldnn::object_type::REORG_YOLO_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reorg_yolo_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
index a8bb63fcfd7c48..6e83709366fc2a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
@@ -208,4 +208,4 @@ attach_resample_impl::attach_resample_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::resample_impl, cldnn::object_type::RESAMPLE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::resample_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp
index 05aed4f0e8f69a..af8fe76b3ad747 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp
@@ -43,4 +43,4 @@ attach_reshape_impl::attach_reshape_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reshape_impl, cldnn::object_type::RESHAPE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reshape_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp
index 2f0c27214017ae..2d6b2601ac6dcb 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp
@@ -75,4 +75,4 @@ attach_reverse_impl::attach_reverse_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reverse_impl, cldnn::object_type::REVERSE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reverse_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/reverse_sequence.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/reverse_sequence.cpp
index a4db466c40c611..f4b89d9fb0f5c3 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reverse_sequence.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reverse_sequence.cpp
@@ -56,4 +56,4 @@ attach_reverse_sequence_impl::attach_reverse_sequence_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reverse_sequence_impl, cldnn::object_type::REVERSE_SEQUENCE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::reverse_sequence_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/roi_align.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/roi_align.cpp
index 3a1ddc1def06ef..64d210a721d25e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/roi_align.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/roi_align.cpp
@@ -98,4 +98,4 @@ attach_roi_align_impl::attach_roi_align_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roi_align_impl, cldnn::object_type::ROI_ALIGN_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roi_align_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/roi_pooling.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/roi_pooling.cpp
index cd739863ffb59d..c7e623f903b512 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/roi_pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/roi_pooling.cpp
@@ -108,4 +108,4 @@ attach_roi_pooling_impl::attach_roi_pooling_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roi_pooling_impl, cldnn::object_type::ROI_POOLING_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roi_pooling_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp
index eabf566017aa07..3d2574d836c6ae 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp
@@ -69,4 +69,4 @@ attach_roll_impl::attach_roll_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roll_impl, cldnn::object_type::ROLL_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::roll_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_elements_update.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_elements_update.cpp
index 60f86bbde7db9b..f393297a0cd35a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_elements_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_elements_update.cpp
@@ -99,5 +99,4 @@ attach_scatter_elements_update_impl::attach_scatter_elements_update_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_elements_update_impl,
-                             cldnn::object_type::SCATTER_ELEMENTS_UPDATE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_elements_update_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
index 8747bd1a181b17..2a1f66690df02b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_nd_update.cpp
@@ -141,4 +141,4 @@ attach_scatter_nd_update_impl::attach_scatter_nd_update_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_nd_update_impl, cldnn::object_type::SCATTER_ND_UPDATE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_nd_update_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
index 49e9d31259981b..b8b063531928dd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.cpp
@@ -94,4 +94,4 @@ attach_scatter_update_impl::attach_scatter_update_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_update_impl, cldnn::object_type::SCATTER_UPDATE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::scatter_update_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
index c128280238abd9..c7c48a44e7b955 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
@@ -87,4 +87,4 @@ attach_select_impl::attach_select_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::select_impl, cldnn::object_type::SELECT_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::select_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
index f95caf65c48e60..844da59e42964e 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/shape_of.cpp
@@ -47,4 +47,4 @@ attach_shape_of_impl::attach_shape_of_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::shape_of_impl, cldnn::object_type::SHAPE_OF_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::shape_of_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/shuffle_channels.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/shuffle_channels.cpp
index 99aeb5eb3130bb..674bc32869b7e4 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/shuffle_channels.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/shuffle_channels.cpp
@@ -74,4 +74,4 @@ attach_shuffle_channels_impl::attach_shuffle_channels_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::shuffle_channels_impl, cldnn::object_type::SHUFFLE_CHANNELS_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::shuffle_channels_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp
index fb5905ceb1c7f8..19e537e8fc2800 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp
@@ -137,4 +137,4 @@ attach_slice_impl::attach_slice_impl() {
 } // namespace ocl
 } // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::slice_impl, cldnn::object_type::SLICE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::slice_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
index bd0c16f19a896c..1b211f63cb8f36 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
@@ -77,4 +77,4 @@ attach_softmax_impl::attach_softmax_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::softmax_impl, cldnn::object_type::SOFTMAX_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::softmax_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_batch.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_batch.cpp
index f29fb6cda50b83..0c7841a9226b07 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_batch.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_batch.cpp
@@ -68,4 +68,4 @@ attach_space_to_batch_impl::attach_space_to_batch_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::space_to_batch_impl, cldnn::object_type::SPACE_TO_BATCH_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::space_to_batch_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_depth.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_depth.cpp
index a4963010495e4c..70556e0e08a0af 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_depth.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/space_to_depth.cpp
@@ -68,4 +68,4 @@ attach_space_to_depth_impl::attach_space_to_depth_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::space_to_depth_impl, cldnn::object_type::SPACE_TO_DEPTH_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::space_to_depth_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
index 3cbc1d4eb7f783..10f181f17fd7f6 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/strided_slice.cpp
@@ -165,4 +165,4 @@ attach_strided_slice_impl::attach_strided_slice_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::strided_slice_impl, cldnn::object_type::STRIDED_SLICE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::strided_slice_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
index b8153a8f9d73f9..d1bcc719e2ace7 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
@@ -76,4 +76,4 @@ attach_tile_impl::attach_tile_impl() {
 }  // namespace ocl
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::tile_impl, cldnn::object_type::TILE_IMPL)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::ocl::tile_impl)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
index 0ea0e571655e7e..4a410289e908ea 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
@@ -152,4 +152,4 @@ attach_concatenation_onednn::attach_concatenation_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::concatenation_onednn, cldnn::object_type::CONCATENATION_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::concatenation_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp
index 593ee455a45fe7..02c00599eec361 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/convolution_onednn.cpp
@@ -266,4 +266,4 @@ attach_convolution_onednn::attach_convolution_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::convolution_onednn, cldnn::object_type::CONVOLUTION_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::convolution_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/deconvolution_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/deconvolution_onednn.cpp
index bd1c6a1fa15662..2848691fb5a300 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/deconvolution_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/deconvolution_onednn.cpp
@@ -168,4 +168,4 @@ attach_deconvolution_onednn::attach_deconvolution_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::deconvolution_onednn, cldnn::object_type::DECONVOLUTION_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::deconvolution_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/fully_connected_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/fully_connected_onednn.cpp
index c01cf59b2030cc..e7b480abeeabd2 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/fully_connected_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/fully_connected_onednn.cpp
@@ -218,4 +218,4 @@ attach_fully_connected_onednn::attach_fully_connected_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::fully_connected_onednn, cldnn::object_type::FULLY_CONNECTED_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::fully_connected_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/gemm_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/gemm_onednn.cpp
index bcf130525feef4..3f51bf59281bed 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/gemm_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/gemm_onednn.cpp
@@ -263,4 +263,4 @@ attach_gemm_onednn::attach_gemm_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::gemm_onednn, cldnn::object_type::GEMM_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::gemm_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/pooling_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/pooling_onednn.cpp
index 61717bc2083647..f1b3d04969f080 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/pooling_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/pooling_onednn.cpp
@@ -129,4 +129,4 @@ attach_pooling_onednn::attach_pooling_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::pooling_onednn, cldnn::object_type::POOLING_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::pooling_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
index 2207245d0e3e94..398546c4774831 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "primitive_inst.h"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 #include "intel_gpu/runtime/error_handler.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 #include "to_string_utils.h"
@@ -17,7 +18,6 @@
 
 #include "reorder/reorder_weights_kernel_selector.h"
 #include "reorder/reorder_kernel_base.h"
-#include "serialization/binary_buffer.hpp"
 
 #include <vector>
 #include <list>
@@ -67,6 +67,10 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl<PType> {
 
     bool is_cpu() const override { return false; }
 
+    // Cache blob format:
+    //     [ dnnl::primitive_attr ]
+    //     [ dnnl::primitive_desc ]
+    //     [ dnnl::cache_blob ]
     void save(BinaryOutputBuffer& ob) const override {
         if (_attrs.get() == nullptr) {
             ob << false;
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/reduction_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/reduction_onednn.cpp
index ef25e17f5d8487..341a2fdb78612b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/reduction_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/reduction_onednn.cpp
@@ -158,4 +158,4 @@ attach_reduction_onednn::attach_reduction_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::reduction_onednn, cldnn::object_type::REDUCTION_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::reduction_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/reorder_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/reorder_onednn.cpp
index 3b7906aace2388..14d5b782bed51c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/reorder_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/reorder_onednn.cpp
@@ -105,4 +105,4 @@ attach_reorder_onednn::attach_reorder_onednn() {
 }  // namespace onednn
 }  // namespace cldnn
 
-BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::reorder_onednn, cldnn::object_type::REORDER_ONEDNN)
+BIND_BINARY_BUFFER_WITH_TYPE(cldnn::onednn::reorder_onednn)
diff --git a/src/plugins/intel_gpu/src/graph/include/data_inst.h b/src/plugins/intel_gpu/src/graph/include/data_inst.h
index bc872844e160e7..bfd541e4ec3330 100644
--- a/src/plugins/intel_gpu/src/graph/include/data_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/data_inst.h
@@ -42,6 +42,8 @@ class typed_primitive_inst<data> : public typed_primitive_inst_base<data> {
 
 public:
     typed_primitive_inst(network& network, data_node const& node);
+    void save(BinaryOutputBuffer& ob) const override;
+    void load(BinaryInputBuffer& ib) override;
 };
 
 using data_inst = typed_primitive_inst<data>;
diff --git a/src/plugins/intel_gpu/src/graph/include/kernel_selector_helper.h b/src/plugins/intel_gpu/src/graph/include/kernel_selector_helper.h
index 3f9b69702b8213..71d8e732c2b47e 100644
--- a/src/plugins/intel_gpu/src/graph/include/kernel_selector_helper.h
+++ b/src/plugins/intel_gpu/src/graph/include/kernel_selector_helper.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 #include "intel_gpu/runtime/engine.hpp"
 #include "intel_gpu/runtime/utils.hpp"
 #include "intel_gpu/runtime/tensor.hpp"
@@ -17,7 +18,6 @@
 #include "kernel_selector_common.h"
 #include "tensor_type.h"
 #include "fused_primitive_desc.h"
-#include "serialization/binary_buffer.hpp"
 
 #include <cstdint>
 #include <string>
diff --git a/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h b/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
index c86171c75f6045..ab87272568ca00 100644
--- a/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/mutable_data_inst.h
@@ -44,9 +44,10 @@ class typed_primitive_inst<mutable_data> : public typed_primitive_inst_base<muta
 
     typed_primitive_inst(network& network, mutable_data_node const& node);
     void set_output_memory(memory::ptr mem, bool check = true, size_t idx = 0) override;
+    const std::list<primitive_id>& get_user_ids() const { return _user_ids; }
 
-    void save(cldnn::BinaryOutputBuffer& ob) const override;
-    void load(cldnn::BinaryInputBuffer& ib) override;
+private:
+    std::list<primitive_id> _user_ids;
 };
 
 using mutable_data_inst = typed_primitive_inst<mutable_data>;
diff --git a/src/plugins/intel_gpu/src/graph/include/primitive_inst.h b/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
index e0bab02d5c5a3e..f2f382381a483e 100644
--- a/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
@@ -14,14 +14,13 @@
 #include "meta_utils.h"
 #include "program_node.h"
 #include "primitive_type.h"
-#include "serialization/binary_buffer.hpp"
-#include "serialization/helpers.hpp"
-#include "serialization/cl_kernel_data_serializer.hpp"
-#include "serialization/object_types.hpp"
-#include "serialization/polymorphic_serializer.hpp"
-#include "serialization/string_serializer.hpp"
-#include "serialization/layout_serializer.hpp"
-#include "serialization/vector_serializer.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
+#include "intel_gpu/graph/serialization/helpers.hpp"
+#include "intel_gpu/graph/serialization/cl_kernel_data_serializer.hpp"
+#include "intel_gpu/graph/serialization/polymorphic_serializer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
+#include "intel_gpu/graph/serialization/layout_serializer.hpp"
+#include "intel_gpu/graph/serialization/vector_serializer.hpp"
 #include "runtime/kernels_cache.hpp"
 
 #include <memory>
@@ -33,8 +32,6 @@ namespace cldnn {
 // checks if any user in a list is a cpu primitive
 bool is_any_user_cpu(const std::list<const program_node*>& users);
 
-primitive_type_id get_type_id(std::string type_str);
-
 class primitive_inst;
 
 template <class PType>
@@ -51,7 +48,7 @@ struct primitive_impl {
 
     virtual std::vector<layout> get_internal_buffer_layouts() const = 0;
     virtual void set_node_params(const program_node&) {}
-    virtual object_type get_type() const { return object_type::NONE; }
+    virtual std::string get_type() const = 0;
     virtual void set_arguments(primitive_inst& instance) = 0;
     virtual void set_arguments(kernel_arguments_data_idx& args_idx) = 0;
     virtual kernel_arguments_data get_arguments(const primitive_inst& instance) const = 0;
@@ -64,11 +61,12 @@ struct primitive_impl {
     virtual bool is_cpu() const { return true; }
     virtual void init_kernels(const kernels_cache&) = 0;
     virtual std::unique_ptr<primitive_impl> clone() const = 0;
-    virtual std::vector<std::string> get_kernel_ids() {
+    virtual std::vector<std::string> get_kernel_ids() const {
         return {};
     }
     virtual std::vector<std::shared_ptr<cldnn::kernel_string>> get_kernels_source() { return {}; }
     virtual void set_kernels(std::vector<kernel::ptr>) {}
+    virtual std::vector<kernel::ptr> get_kernels() const { return {}; }
     virtual void set_kernel_ids(std::vector<kernel_id> kernel_ids) {}
     virtual void save(cldnn::BinaryOutputBuffer& ob) const {}
     virtual void load(cldnn::BinaryInputBuffer& ib) {}
diff --git a/src/plugins/intel_gpu/src/graph/include/serialization/object_types.hpp b/src/plugins/intel_gpu/src/graph/include/serialization/object_types.hpp
deleted file mode 100644
index 3fcf15d8eaec26..00000000000000
--- a/src/plugins/intel_gpu/src/graph/include/serialization/object_types.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (C) 2018-2022 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma once
-
-namespace cldnn {
-
-enum class object_type {
-    ACTIVATION_IMPL,
-    ADAPTIVE_POOLING_IMPL,
-    ARG_MAX_MIN_IMPL,
-    ASSIGN_IMPL,
-    AVERAGE_UNPOOLING_IMPL,
-    BATCH_TO_SPACE_IMPL,
-    BINARY_CONVOLUTION_IMPL,
-    BORDER_IMPL,
-    BROADCAST_IMPL,
-    BUCKETIZE_IMPL,
-    CONCATENATION_IMPL,
-    CONVERT_COLOR_IMPL,
-    CONVOLUTION_IMPL,
-    CROP_IMPL,
-    CTC_GREEDY_DECODER_IMPL,
-    CTC_LOSS_IMPL,
-    CUM_SUM_IMPL,
-    CUSTOM_GPU_PRIMITIVE_IMPL,
-    DECONVOLUTION_IMPL,
-    DEFORMABLE_CONV_IMPL,
-    DEFORMABLE_INTERP_IMPL,
-    DEPTH_TO_SPACE_IMPL,
-    DETECTION_OUTPUT_IMPL_OCL,
-    DFT_IMPL,
-    ELTWISE_IMPL,
-    EMBEDDING_BAG_IMPL,
-    EXPERIMENTAL_DETECTRON_DETECTION_OUTPUT_IMPL,
-    EXPERIMENTAL_DETECTRON_GENERATE_PROPOSALS_SINGLE_IMAGE_IMPL,
-    EXPERIMENTAL_DETECTRON_PRIOR_GRID_GENERATOR_IMPL,
-    EXPERIMENTAL_DETECTRON_ROI_FEATURE_EXTRACTOR_IMPL,
-    EXPERIMENTAL_DETECTRON_TOPK_ROIS_IMPL,
-    EXTRACT_IMAGE_PATCHES_IMPL,
-    EYE_IMPL,
-    FULLY_CONNECTED_IMPL,
-    FUSED_CONV_ELTWISE_IMPL,
-    GATHER_ELEMENTS_IMPL,
-    GATHER_ND_IMPL,
-    GATHER_TREE_IMPL,
-    GATHER_IMPL,
-    GEMM_IMPL,
-    GENERATE_PROPOSALS_IMPL,
-    GENERIC_LAYER_IMPL,
-    GRID_SAMPLE_IMPL,
-    GRN_IMPL,
-    LRN_IMPL,
-    LSTM_DYNAMIC_INPUT_IMPL,
-    LSTM_DYNAMIC_TIMELOOP_IMPL,
-    LSTM_ELT_IMPL,
-    LSTM_GEMM_IMPL,
-    MAX_UNPOOLING_IMPL,
-    MULTICLASS_NMS_IMPL,
-    MUTABLE_DATA_IMPL,
-    MVN_IMPL,
-    NON_MAX_SUPPRESSION_IMPL_OCL,
-    COUNT_NONZERO_IMPL,
-    GATHER_NONZERO_IMPL,
-    NORMALIZE_IMPL,
-    ONE_HOT_IMPL,
-    PERMUTE_IMPL,
-    POOLING_IMPL,
-    PRIOR_BOX_IMPL,
-    PYRAMID_ROI_ALIGN_IMPL,
-    QUANTIZE_IMPL,
-    RANDOM_UNIFORM_IMPL,
-    RANGE_IMPL,
-    READ_VALUE_IMPL,
-    REDUCE_IMPL,
-    REGION_YOLO_IMPL,
-    REORDER_IMPL,
-    REORG_YOLO_IMPL,
-    RESAMPLE_IMPL,
-    RESHAPE_IMPL,
-    REVERSE_SEQUENCE_IMPL,
-    REVERSE_IMPL,
-    ROI_ALIGN_IMPL,
-    ROI_POOLING_IMPL,
-    ROLL_IMPL,
-    SCALE_IMPL,
-    SCATTER_ELEMENTS_UPDATE_IMPL,
-    SCATTER_ND_UPDATE_IMPL,
-    SCATTER_UPDATE_IMPL,
-    SELECT_IMPL,
-    SHAPE_OF_IMPL,
-    SHUFFLE_CHANNELS_IMPL,
-    SLICE_IMPL,
-    SOFTMAX_IMPL,
-    SPACE_TO_BATCH_IMPL,
-    SPACE_TO_DEPTH_IMPL,
-    STRIDED_SLICE_IMPL,
-    TILE_IMPL,
-    WAIT_FOR_EVENTS_IMPL,
-    CONDITION_IMPL,
-    LOOP_IMPL,
-    DETECTION_OUTPUT_IMPL_CPU,
-    NON_MAX_SUPPRESSION_IMPL_CPU,
-    PROPOSAL_IMPL_CPU,
-    DATA_INST,
-    EXECUTABLE_INST,
-    CONVOLUTION_ONEDNN,
-    POOLING_ONEDNN,
-    CONCATENATION_ONEDNN,
-    DECONVOLUTION_ONEDNN,
-    FULLY_CONNECTED_ONEDNN,
-    GEMM_ONEDNN,
-    REDUCTION_ONEDNN,
-    REORDER_ONEDNN,
-    NONE
-};
-
-}  //namespace cldnn
\ No newline at end of file
diff --git a/src/plugins/intel_gpu/src/graph/input_layout.cpp b/src/plugins/intel_gpu/src/graph/input_layout.cpp
index 607bae3f1f1a6f..e884ae184e7210 100644
--- a/src/plugins/intel_gpu/src/graph/input_layout.cpp
+++ b/src/plugins/intel_gpu/src/graph/input_layout.cpp
@@ -25,10 +25,7 @@ bool has_optimized_users(input_layout_node const& node) {
 }  // namespace
 
 namespace cldnn {
-primitive_type_id input_layout::type_id() {
-    static primitive_type_base<input_layout> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(input_layout)
 
 input_layout_node::typed_program_node(const std::shared_ptr<input_layout> dprim, program& prog)
     : parent(dprim, prog) {
diff --git a/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp b/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp
index 8721234761a12a..706e784e7023e8 100644
--- a/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp
+++ b/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp
@@ -8,9 +8,9 @@
 #include "kernel_selector_params.h"
 #include "to_string_utils.h"
 #include "program_node.h"
-#include "serialization/layout_serializer.hpp"
-#include "serialization/string_serializer.hpp"
-#include "serialization/vector_serializer.hpp"
+#include "intel_gpu/graph/serialization/layout_serializer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
+#include "intel_gpu/graph/serialization/vector_serializer.hpp"
 
 #include <string>
 #include <vector>
diff --git a/src/plugins/intel_gpu/src/graph/loop.cpp b/src/plugins/intel_gpu/src/graph/loop.cpp
index ff482136510e3c..516d452031f843 100644
--- a/src/plugins/intel_gpu/src/graph/loop.cpp
+++ b/src/plugins/intel_gpu/src/graph/loop.cpp
@@ -14,10 +14,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id loop::type_id() {
-    static primitive_type_base<loop> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(loop)
 
 static bool check_if_axis_is_set_properly(loop_node const & node) {
     const auto& input_primitive_maps = node.get_input_primitive_maps();
diff --git a/src/plugins/intel_gpu/src/graph/lrn.cpp b/src/plugins/intel_gpu/src/graph/lrn.cpp
index d60c4b5909a3b3..9444e357245740 100644
--- a/src/plugins/intel_gpu/src/graph/lrn.cpp
+++ b/src/plugins/intel_gpu/src/graph/lrn.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lrn::type_id() {
-    static primitive_type_base<lrn> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lrn)
 
 layout lrn_inst::calc_output_layout(lrn_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/lstm.cpp b/src/plugins/intel_gpu/src/graph/lstm.cpp
index 077336f48f1187..eba2522110c44e 100644
--- a/src/plugins/intel_gpu/src/graph/lstm.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm::type_id() {
-    static primitive_type_base<lstm> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm)
 
 layout lstm_inst::calc_output_layout(lstm_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/lstm_dynamic.cpp b/src/plugins/intel_gpu/src/graph/lstm_dynamic.cpp
index 409eca411d6e96..282f20cb2aae4a 100644
--- a/src/plugins/intel_gpu/src/graph/lstm_dynamic.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm_dynamic.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm_dynamic::type_id() {
-    static primitive_type_base<lstm_dynamic> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm_dynamic)
 
 // input_tensor:   [b: batch, f: max_sequence_length, x: input_size, y: direction]
 // weights_tensor: [b: 1, f: direction, x: input_size, y: 4 * hidden_size]
diff --git a/src/plugins/intel_gpu/src/graph/lstm_dynamic_input.cpp b/src/plugins/intel_gpu/src/graph/lstm_dynamic_input.cpp
index eeb9020d5c419a..ff91a43107a6a6 100644
--- a/src/plugins/intel_gpu/src/graph/lstm_dynamic_input.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm_dynamic_input.cpp
@@ -11,10 +11,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm_dynamic_input::type_id() {
-    static primitive_type_base<lstm_dynamic_input> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm_dynamic_input)
 // input_tensor:   [b: batch, f: max_sequence_length, x: input_size, y: direction]
 // weights_tensor: [b: 1, f: direction, x: input_size, y: 4 * hidden_size]
 // output_tensor:  [b: batch, f: max_sequence_length, x: 4 * hidden_size, y: direction]
diff --git a/src/plugins/intel_gpu/src/graph/lstm_dynamic_timeloop.cpp b/src/plugins/intel_gpu/src/graph/lstm_dynamic_timeloop.cpp
index e84cbf0cd7d7fd..dfe062deeda739 100644
--- a/src/plugins/intel_gpu/src/graph/lstm_dynamic_timeloop.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm_dynamic_timeloop.cpp
@@ -11,10 +11,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm_dynamic_timeloop::type_id() {
-    static primitive_type_base<lstm_dynamic_timeloop> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm_dynamic_timeloop)
 
 program_node& lstm_dynamic_timeloop_node::get_dependency_by_name(std::string val) const {
     return get_dependency(get_dependency_idx(val));
diff --git a/src/plugins/intel_gpu/src/graph/lstm_elt.cpp b/src/plugins/intel_gpu/src/graph/lstm_elt.cpp
index 62bb1f59fc514c..60702247f73faa 100644
--- a/src/plugins/intel_gpu/src/graph/lstm_elt.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm_elt.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm_elt::type_id() {
-    static primitive_type_base<lstm_elt> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm_elt)
 
 layout lstm_elt_inst::calc_output_layout(lstm_elt_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/lstm_gemm.cpp b/src/plugins/intel_gpu/src/graph/lstm_gemm.cpp
index 48d4fcdf5e75c8..60392acd7a50c3 100644
--- a/src/plugins/intel_gpu/src/graph/lstm_gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/lstm_gemm.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id lstm_gemm::type_id() {
-    static primitive_type_base<lstm_gemm> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(lstm_gemm)
 
 layout lstm_gemm_inst::calc_output_layout(lstm_gemm_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/matrix_nms.cpp b/src/plugins/intel_gpu/src/graph/matrix_nms.cpp
index e7154e28d33acb..c2c927137ea834 100644
--- a/src/plugins/intel_gpu/src/graph/matrix_nms.cpp
+++ b/src/plugins/intel_gpu/src/graph/matrix_nms.cpp
@@ -11,10 +11,7 @@
 #include "primitive_type_base.h"
 
 namespace cldnn {
-primitive_type_id matrix_nms::type_id() {
-    static primitive_type_base<matrix_nms> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(matrix_nms)
 
 layout matrix_nms_inst::calc_output_layout(const matrix_nms_node& node, const kernel_impl_params& impl_param) {
     const auto primitive = impl_param.typed_desc<matrix_nms>();
diff --git a/src/plugins/intel_gpu/src/graph/multiclass_nms.cpp b/src/plugins/intel_gpu/src/graph/multiclass_nms.cpp
index b98a85bdef7816..394ea4bac47cc3 100644
--- a/src/plugins/intel_gpu/src/graph/multiclass_nms.cpp
+++ b/src/plugins/intel_gpu/src/graph/multiclass_nms.cpp
@@ -10,10 +10,7 @@
 #include "primitive_type_base.h"
 
 namespace cldnn {
-primitive_type_id multiclass_nms::type_id() {
-    static primitive_type_base<multiclass_nms> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(multiclass_nms)
 
 layout multiclass_nms_inst::calc_output_layout(const multiclass_nms_node& node, const kernel_impl_params& impl_param) {
     const auto input_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/mutable_data.cpp b/src/plugins/intel_gpu/src/graph/mutable_data.cpp
index cf3e5a763e8145..95e345aac757b8 100644
--- a/src/plugins/intel_gpu/src/graph/mutable_data.cpp
+++ b/src/plugins/intel_gpu/src/graph/mutable_data.cpp
@@ -14,10 +14,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id mutable_data::type_id() {
-    static primitive_type_base<mutable_data> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(mutable_data)
 
 namespace {
 memory::ptr attach_or_copy_data(network& network, memory::ptr mem, bool reuse) {
@@ -77,35 +74,11 @@ void mutable_data_inst::set_output_memory(memory::ptr mem_new, bool check, size_
 }
 
 mutable_data_inst::typed_primitive_inst(network& network, mutable_data_node const& node)
-    : parent(network, node, attach_or_copy_data(network, node.get_attached_memory_ptr(), network.is_primary_stream())) {}
-
-void mutable_data_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    parent::save(ob);
-
-    if (!_mem_allocated) {
-        for (size_t dep_idx = 0; dep_idx < _deps.size(); ++dep_idx) {
-            for (size_t m_idx = 0; m_idx < _deps[dep_idx]->_deps.size(); ++m_idx) {
-                if (get_network().get_engine().is_the_same_buffer(*_outputs[0], *_deps[dep_idx]->_deps[m_idx]->_outputs[0])) {
-                    ob << true << dep_idx << m_idx;
-                    return;
-                }
-            }
-        }
+    : parent(network, node, attach_or_copy_data(network, node.get_attached_memory_ptr(), network.is_primary_stream())) {
+    const auto& users = get_users();
+    for (const auto& usr : users) {
+        _user_ids.emplace_back(usr->id());
     }
-    ob << false;
 }
 
-void mutable_data_inst::load(cldnn::BinaryInputBuffer& ib) {
-    parent::load(ib);
-
-    bool from_dep;
-    ib >> from_dep;
-    if (from_dep && !_mem_allocated) {
-        size_t dep_idx, m_idx;
-        ib >> dep_idx >> m_idx;
-
-        auto prev_node = get_network().get_primitive(_dep_ids[dep_idx]);
-        _outputs[0] = get_network().get_primitive(prev_node->_dep_ids[m_idx])->output_memory_ptr();
-    }
-}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/mvn.cpp b/src/plugins/intel_gpu/src/graph/mvn.cpp
index 02ee0db81b99a6..fc1a23a34ab735 100644
--- a/src/plugins/intel_gpu/src/graph/mvn.cpp
+++ b/src/plugins/intel_gpu/src/graph/mvn.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id mvn::type_id() {
-    static primitive_type_base<mvn> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(mvn)
 
 layout mvn_inst::calc_output_layout(mvn_node const& node, kernel_impl_params const& impl_param) {
     auto input_node_layout = impl_param.get_non_padded_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/network.cpp b/src/plugins/intel_gpu/src/graph/network.cpp
index fb6c090754b846..960d7eacda5fca 100644
--- a/src/plugins/intel_gpu/src/graph/network.cpp
+++ b/src/plugins/intel_gpu/src/graph/network.cpp
@@ -18,6 +18,7 @@
 
 #include "intel_gpu/graph/program.hpp"
 #include "intel_gpu/graph/network.hpp"
+#include "intel_gpu/graph/serialization/map_serializer.hpp"
 #include "assign_inst.h"
 #include "read_value_inst.h"
 #include "reshape_inst.h"
@@ -32,7 +33,6 @@
 #include "program_helpers.h"
 #include "runtime/cldnn_itt.hpp"
 #include "kernels_cache.hpp"
-#include "serialization/map_serializer.hpp"
 
 #include <algorithm>
 #include <string>
@@ -269,6 +269,11 @@ void wait_for_the_turn() {}
 #endif
 }  // namespace
 
+static uint32_t get_unique_net_id() {
+    static std::atomic<uint32_t> id_gen{0};
+    return ++id_gen;
+}
+
 /*
 Network will always have net_id = 0 when it will be cldnn internal micronetwork (created i.e by propagate_constants
 opt pass).
@@ -281,9 +286,8 @@ network::network(program::ptr program, stream::ptr stream, bool is_internal, boo
     , _internal(is_internal)
     , _is_primary_stream(is_primary_stream)
     , _reset_arguments(true) {
-    static std::atomic<uint32_t> id_gen{0};
     if (!_internal) {
-        net_id = ++id_gen;
+        net_id = get_unique_net_id();
     }
 
     GPU_DEBUG_GET_INSTANCE(debug_config);
@@ -327,31 +331,25 @@ network::network(program::ptr program, stream::ptr stream, uint16_t stream_id)
 
 network::network(cldnn::BinaryInputBuffer& ib, stream::ptr stream, engine& engine, uint16_t stream_id)
     : _program(nullptr)
-    , _engine(ib.get_engine())
+    , _engine(engine)
     , _stream(stream)
     , _memory_pool(new memory_pool(engine))
     , _internal(false)
     , _is_primary_stream(false)
     , _reset_arguments(true) {
-    net_id += 1;
+    net_id = get_unique_net_id();
 
-    uint32_t prog_id;
-    std::vector<std::string> batch_header_str;
-    ib >> prog_id;
-    ib >> batch_header_str;
-    kernels_cache kernels_cache(get_engine(), prog_id, batch_header_str);
+    kernels_cache kernels_cache(get_engine(), 0, {""});
     ib >> kernels_cache;
 
     int num_data_nodes;
     ib >> num_data_nodes;
 
-    _memory_pool->clear_pool_for_network(net_id);
-
     for (int i = 0; i < num_data_nodes; ++i) {
         std::string type;
         std::string _primitive_id;
         ib >> type >> _primitive_id;
-        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = cldnn::get_type_id(type)->create_instance(*this);
+        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = prim_map_storage::instance().get_type_id(type)->create_instance(*this);
         ib >> *new_primitive_inst;
         _primitives[_primitive_id] = new_primitive_inst;
     }
@@ -365,7 +363,7 @@ network::network(cldnn::BinaryInputBuffer& ib, stream::ptr stream, engine& engin
 
     for (auto& type : _exec_order_types) {
         ib >> type;
-        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = cldnn::get_type_id(type)->create_instance(*this);
+        std::shared_ptr<cldnn::primitive_inst> new_primitive_inst = prim_map_storage::instance().get_type_id(type)->create_instance(*this);
         _exec_order.emplace_back(new_primitive_inst);
     }
 
@@ -375,12 +373,18 @@ network::network(cldnn::BinaryInputBuffer& ib, stream::ptr stream, engine& engin
     for (const auto& p_inst : _exec_order) {
         ib >> *p_inst;
         _primitives[p_inst->id()] = p_inst;
+        p_inst->init_kernels(kernels_cache);
+    }
+
+    for (auto& item : _primitives) {
+        auto& p_inst = item.second;
         if (p_inst->is_input())
             _inputs.push_back(p_inst);
-        if (p_inst->is_output())
+        if (p_inst->is_output()) {
             _outputs.push_back(p_inst);
-
-        p_inst->init_kernels(kernels_cache);
+            if (p_inst->type() == cldnn::data::type_id())
+                _data_outputs.push_back(p_inst);
+        }
     }
 
     for (auto p_inst : _exec_order) {
@@ -428,8 +432,18 @@ network::~network() {
     }
 }
 
+// Cache blob format:
+//     [ cldnn::kernels_cache ]
+//     [ non executable primitive_inst ]
+//     [ executable primitive_inst ]
+//     [ memory reuse information ]
 void network::save(cldnn::BinaryOutputBuffer& ob) {
-    ob << _program->get_kernels_cache();
+    kernels_cache kernels_cache(get_engine(), 0, {""});
+    for (const auto& p_inst : _exec_order) {
+        if (p_inst->get_impl() != nullptr)
+            kernels_cache.add_kernels(p_inst->get_impl()->get_kernel_ids(), p_inst->get_impl()->get_kernels());
+    }
+    ob << kernels_cache;
 
     int num_data_nodes = 0;
     for (const auto& p_inst : _primitives) {
@@ -594,9 +608,9 @@ network::output_chains_map::iterator network::add_output_chain(std::shared_ptr<p
         }
 
         //then users
-        const auto& users = p_inst->get_users();
-        for (const auto& usr : users) {
-            auto usr_prim = get_primitive(usr->id());
+        const auto& user_ids = mdata_ptr->get_user_ids();
+        for (const auto& id : user_ids) {
+            auto usr_prim = get_primitive(id);
             if (eng.is_the_same_buffer(mem_orig, usr_prim->output_memory())) {
                 chain.push_back(usr_prim);
             }
diff --git a/src/plugins/intel_gpu/src/graph/non_max_suppression.cpp b/src/plugins/intel_gpu/src/graph/non_max_suppression.cpp
index 7d1b38def99c92..1f6c7d72f5032f 100644
--- a/src/plugins/intel_gpu/src/graph/non_max_suppression.cpp
+++ b/src/plugins/intel_gpu/src/graph/non_max_suppression.cpp
@@ -11,10 +11,7 @@
 #include "nms_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id non_max_suppression::type_id() {
-    static primitive_type_base<non_max_suppression> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(non_max_suppression)
 
 layout non_max_suppression_inst::calc_output_layout(non_max_suppression_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<non_max_suppression>();
diff --git a/src/plugins/intel_gpu/src/graph/non_zero.cpp b/src/plugins/intel_gpu/src/graph/non_zero.cpp
index cbe60bb6926b2f..32c173ef73e216 100644
--- a/src/plugins/intel_gpu/src/graph/non_zero.cpp
+++ b/src/plugins/intel_gpu/src/graph/non_zero.cpp
@@ -16,10 +16,7 @@ namespace cldnn {
 // -----------------------------------------------
 // count_nonzero
 // -----------------------------------------------
-primitive_type_id count_nonzero::type_id() {
-    static primitive_type_base<count_nonzero> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(count_nonzero)
 
 layout count_nonzero_inst::calc_output_layout(count_nonzero_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(node.get_primitive()->output_data_type) == false &&
@@ -60,10 +57,7 @@ void count_nonzero_inst::on_execute() {
 // -----------------------------------------------
 // gather_nonzero
 // -----------------------------------------------
-primitive_type_id gather_nonzero::type_id() {
-    static primitive_type_base<gather_nonzero> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gather_nonzero)
 
 layout gather_nonzero_inst::calc_output_layout(gather_nonzero_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(node.get_primitive()->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/normalize.cpp b/src/plugins/intel_gpu/src/graph/normalize.cpp
index efa690e770030a..5f70c59093e56b 100644
--- a/src/plugins/intel_gpu/src/graph/normalize.cpp
+++ b/src/plugins/intel_gpu/src/graph/normalize.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id normalize::type_id() {
-    static primitive_type_base<normalize> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(normalize)
 
 layout normalize_inst::calc_output_layout(normalize_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/one_hot.cpp b/src/plugins/intel_gpu/src/graph/one_hot.cpp
index d222509e44d570..3dd48a8a7adcd2 100644
--- a/src/plugins/intel_gpu/src/graph/one_hot.cpp
+++ b/src/plugins/intel_gpu/src/graph/one_hot.cpp
@@ -13,10 +13,7 @@
 #include "one_hot_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id one_hot::type_id() {
-    static primitive_type_base<one_hot> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(one_hot)
 
 static bool is_output_bfzyx(const layout& input, int32_t axis) {
     if (input.format == format::bfzyx)
diff --git a/src/plugins/intel_gpu/src/graph/permute.cpp b/src/plugins/intel_gpu/src/graph/permute.cpp
index 89f6ec10f1c580..d25afad5acd157 100644
--- a/src/plugins/intel_gpu/src/graph/permute.cpp
+++ b/src/plugins/intel_gpu/src/graph/permute.cpp
@@ -13,11 +13,7 @@
 #include <vector>
 
 namespace cldnn {
-
-primitive_type_id permute::type_id() {
-    static primitive_type_base<permute> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(permute)
 
 layout permute_inst::calc_output_layout(permute_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/pooling.cpp b/src/plugins/intel_gpu/src/graph/pooling.cpp
index 167bbcee23dced..581bae675a0c4f 100644
--- a/src/plugins/intel_gpu/src/graph/pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/pooling.cpp
@@ -16,10 +16,7 @@
 using namespace ov::intel_gpu;
 
 namespace cldnn {
-primitive_type_id pooling::type_id() {
-    static primitive_type_base<pooling> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(pooling)
 
 layout pooling_inst::calc_output_layout(parent::typed_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<pooling>();
diff --git a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
index ae849ed9ced0a6..a04ec05f219100 100644
--- a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
+++ b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
@@ -19,12 +19,12 @@
 #include "intel_gpu/plugin/common_utils.hpp"
 
 #include "intel_gpu/graph/network.hpp"
+#include "intel_gpu/graph/serialization/set_serializer.hpp"
 #include "intel_gpu/runtime/engine.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 
 #include "intel_gpu/runtime/error_handler.hpp"
 #include "intel_gpu/runtime/debug_configuration.hpp"
-#include "serialization/set_serializer.hpp"
 #include "json_object.h"
 #include <string>
 #include <stack>
@@ -498,8 +498,7 @@ void primitive_inst::set_arguments() {
 }
 
 void primitive_inst::build_deps() {
-    if (_node == nullptr)
-        return;
+    OPENVINO_ASSERT(_node != nullptr, "_node should not be nullptr for build_deps.");
 
     if (_deps.empty() && !_node->get_dependencies().empty()) {
         _deps = _network.get_primitives(_node->get_dependencies());
@@ -515,7 +514,7 @@ void primitive_inst::rebuild_deps(
 
     _deps.resize(_dep_ids.size());
     for (size_t i = 0; i < _dep_ids.size(); i++) {
-        OPENVINO_ASSERT((primitives.count(_dep_ids[i]) > 0), _dep_ids[i], "is not found in _primitives");
+        OPENVINO_ASSERT((primitives.count(_dep_ids[i]) > 0), _dep_ids[i], "is not found in primitives while rebuilding _deps");
         _deps[i] = primitives.at(_dep_ids[i]);
     }
 }
@@ -533,7 +532,7 @@ void primitive_inst::rebuild_exec_deps(
                 break;
             }
         }
-        OPENVINO_ASSERT(found, _exec_dep_ids[i], "not found in _exec_order");
+        OPENVINO_ASSERT(found, _exec_dep_ids[i], "not found in primitives while rebuilding _exec_deps");
     }
 }
 
@@ -1034,79 +1033,99 @@ std::string primitive_inst::get_implementation_name() const {
     return "undef";
 }
 
-void primitive_inst::save(cldnn::BinaryOutputBuffer& ob) const {
-    if (type() == cldnn::data::type_id() ||
-       (type() == cldnn::mutable_data::type_id() && _impl == nullptr)) {
-        object_type _object_type = object_type::DATA_INST;
-        ob << cldnn::make_data(&_object_type, sizeof(object_type));
-        ob << _node->get_primitive()->type_string();
-        _impl_params->save(ob);
-        ob << _outputs[0]->get_layout();
-
-        const auto _allocation_type = _outputs[0]->get_allocation_type();
-        ob << make_data(&_allocation_type, sizeof(_allocation_type));
+static primitive_id find_dep_by_mem(const cldnn::primitive_inst* p_inst, memory& mem_ptr, int max_dist = 5) {
+    std::vector<std::pair<primitive_id, int>> queue;
+    size_t head = 0;
 
-        size_t data_size = _outputs[0]->size();
-        ob << cldnn::make_data(&data_size, sizeof(size_t));
+    for (auto& p_inst : p_inst->dependencies())
+        queue.emplace_back(std::make_pair(p_inst->id(), 0));
 
-        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-            ob << cldnn::make_data(_outputs[0]->buffer_ptr(), data_size);
-        } else {
-            mem_lock<char, mem_lock_type::read> lock{_outputs[0], get_node().get_program().get_stream()};
-            ob << cldnn::make_data(lock.data(), data_size);
-        }
-    } else {
-        object_type _object_type = object_type::EXECUTABLE_INST;
-        ob << cldnn::make_data(&_object_type, sizeof(object_type));
+    const network& const_network = p_inst->get_network();
+    while (head < queue.size()) {
+        auto curr_item = queue.at(head);
+        auto curr_prim = const_network.get_primitive(curr_item.first);
+
+        if (p_inst->get_network().get_engine().is_the_same_buffer(mem_ptr, curr_prim->output_memory()))
+            return curr_prim->id();
+
+        if (max_dist > curr_item.second)
+            for (auto& p_inst : curr_prim->dependencies())
+                queue.emplace_back(std::make_pair(p_inst->id(), curr_item.second+1));
 
+        head += 1;
+    }
+
+    return "NOT_FOUND";
+}
+
+// Cache blob format:
+//     [ primitive_impl ]
+//     [ kernel_impl_params ]
+//     [ member variables of primitive_inst ]
+//     [ output memory information ]
+//     [ memory dependency information ]
+//     [ execution dependency information ]
+//     [ intermediate memory information ]
+void primitive_inst::save(cldnn::BinaryOutputBuffer& ob) const {
+    if (_impl != nullptr) {
+        ob << true;
         kernel_arguments_data args = _impl->get_arguments(*this);
         kernel_arguments_data_idx args_idx;
         convert_args(args, args_idx);
         _impl->set_arguments(args_idx);
-
-        _impl_params->save(ob);
-        ob.setKernlImplParams(_impl_params.get());
         ob << _impl;
+    } else {
+        ob << false;
+    }
 
-        ob << _node_output_layout;
-        ob << has_mutable_input();
-        ob << mem_allocated();
-        ob << is_dynamic();
-        ob << _node->get_primitive()->type_string();
-        ob << id();
-        ob << org_id();
-        ob << is_input();
-        ob << is_output();
-        ob << inputs_memory_count();
-        ob << outputs_memory_count();
-        ob << get_fused_mem_count();
-        ob << get_fused_mem_offset();
-        ob << can_be_optimized();
-        ob << can_share_buffer();
-        ob << is_constant();
-
-        ob << _outputs[0]->get_layout();
-        const auto _allocation_type = _outputs[0]->get_allocation_type();
-        ob << make_data(&_allocation_type, sizeof(_allocation_type));
+    _impl_params->save(ob);
+    ob.setKernlImplParams(_impl_params.get());
+
+    ob << _node_output_layout;
+    ob << has_mutable_input();
+    ob << mem_allocated();
+    ob << is_dynamic();
+    ob << _node->get_primitive()->type_string();
+    ob << id();
+    ob << org_id();
+    ob << is_input();
+    ob << is_output();
+    ob << inputs_memory_count();
+    ob << outputs_memory_count();
+    ob << get_fused_mem_count();
+    ob << get_fused_mem_offset();
+    ob << can_be_optimized();
+    ob << can_share_buffer();
+    ob << is_constant();
+
+    if (type() == cldnn::data::type_id()) {
+        return;
+    }
 
-        ob << _node->get_memory_dependencies();
+    ob << _outputs[0]->get_layout();
+    const auto _allocation_type = _outputs[0]->get_allocation_type();
+    ob << make_data(&_allocation_type, sizeof(_allocation_type));
 
-        ob << _deps.size();
-        for (const auto& dep : _deps) {
-            ob << dep->id();
-        }
+    ob << _node->get_memory_dependencies();
 
-        ob << _exec_deps.size();
-        for (const auto& dep : _exec_deps) {
-            ob << dep->id();
-        }
+    ob << _deps.size();
+    for (const auto& dep : _deps) {
+        ob << dep->id();
+    }
 
-        ob << _intermediates_memory.size();
-        for (const auto& ibuf : _intermediates_memory) {
-            ob << ibuf->get_layout();
-            const auto _allocation_type = ibuf->get_allocation_type();
-            ob << make_data(&_allocation_type, sizeof(_allocation_type));
-        }
+    ob << _exec_deps.size();
+    for (const auto& dep : _exec_deps) {
+        ob << dep->id();
+    }
+
+    if (!mem_allocated())
+        ob << find_dep_by_mem(this, output_memory());
+
+    ob << _intermediates_memory.size();
+    for (const auto& ibuf : _intermediates_memory) {
+        ob << ibuf->get_layout();
+        const auto _allocation_type = ibuf->get_allocation_type();
+        ob << make_data(&_allocation_type, sizeof(_allocation_type));
     }
 }
 
@@ -1141,122 +1160,99 @@ void primitive_inst::convert_args(const kernel_arguments_data& args, kernel_argu
 }
 
 int32_t primitive_inst::get_index_in_deps(memory::cptr arg) const {
-    uint32_t idx = 0;
-
-    for (idx = 0; idx < _deps.size(); ++idx) {
+    for (uint32_t idx = 0; idx < _deps.size(); ++idx) {
         if (arg == _deps[idx]->_outputs[0])
-            break;
+            return idx;
     }
 
-    if (idx == _deps.size())
-        std::cout << "[get_index_in_deps]: not found" << std::endl;
-
-    return (idx == _deps.size()) ? -1 : idx;
+    IE_THROW() << "[get_index_in_deps]: not found in _deps";
 }
 
 void primitive_inst::load(cldnn::BinaryInputBuffer& ib) {
-    object_type _object_type;
-    ib >> make_data(&_object_type, sizeof(object_type));
-
-    if (_object_type == object_type::DATA_INST) {
-        std::string type_str;
-        ib >> type_str;
-        _type = get_type_id(type_str);
-
-        _impl_params.release();
-        _impl_params = make_unique<kernel_impl_params>();
-        _impl_params->load(ib);
-
-        layout output_layout = layout(cldnn::data_types::bin, cldnn::format::any, cldnn::tensor());
-        ib >> output_layout;
-
-        allocation_type _allocation_type;
-        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
-
-        size_t data_size;
-        ib >> cldnn::make_data(&data_size, sizeof(size_t));
-        _outputs[0] = get_network().get_memory_pool().get_memory(output_layout, _allocation_type, false);
-
-        if (_allocation_type == allocation_type::usm_host || _allocation_type == allocation_type::usm_shared) {
-            ib >> cldnn::make_data(_outputs[0]->buffer_ptr(), data_size);
-        } else {
-            char *_buf = new char[data_size];
-            ib >> cldnn::make_data(_buf, data_size);
-            _outputs[0]->copy_from(get_network().get_stream(), _buf);
-            delete[] _buf;
-        }
-    } else if (_object_type == object_type::EXECUTABLE_INST) {
-        _impl_params.release();
-        _impl_params = make_unique<kernel_impl_params>();
-        _impl_params->load(ib);
+    bool has_impl;
+    ib >> has_impl;
+    if (has_impl) {
         _impl.release();
-        ib.setKernlImplParams(_impl_params.get());
         ib >> _impl;
+    }
 
-        ib >> _node_output_layout;
-        ib >> _has_mutable_input;
-        ib >> _mem_allocated;
-        ib >> _is_dynamic;
-        std::string type_str;
-        ib >> type_str;
-        _type = get_type_id(type_str);
-        ib >> _id;
-        ib >> _org_id;
-        ib >> _is_input;
-        ib >> _is_output;
-        ib >> _inputs_memory_count;
-        ib >> _outputs_memory_count;
-        ib >> _fused_mem_count;
-        ib >> _fused_mem_offset;
-        ib >> _can_be_optimized;
-        ib >> _can_share_buffer;
-        ib >> _is_constant;
-
-        layout output_layout = layout(cldnn::data_types::bin, cldnn::format::any, cldnn::tensor());
-        ib >> output_layout;
+    _impl_params.release();
+    _impl_params = make_unique<kernel_impl_params>();
+    _impl_params->load(ib);
+    ib.setKernlImplParams(_impl_params.get());
+
+    ib >> _node_output_layout;
+    ib >> _has_mutable_input;
+    ib >> _mem_allocated;
+    ib >> _is_dynamic;
+    std::string type_str;
+    ib >> type_str;
+    _type = cldnn::prim_map_storage::instance().get_type_id(type_str);
+    ib >> _id;
+    ib >> _org_id;
+    ib >> _is_input;
+    ib >> _is_output;
+    ib >> _inputs_memory_count;
+    ib >> _outputs_memory_count;
+    ib >> _fused_mem_count;
+    ib >> _fused_mem_offset;
+    ib >> _can_be_optimized;
+    ib >> _can_share_buffer;
+    ib >> _is_constant;
+
+    if (type() == cldnn::data::type_id()) {
+        return;
+    }
 
-        allocation_type _allocation_type;
-        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
+    layout output_layout = layout();
+    ib >> output_layout;
 
-        std::set<primitive_id> _node_mem_deps;
-        ib >> _node_mem_deps;
+    allocation_type _allocation_type;
+    ib >> make_data(&_allocation_type, sizeof(_allocation_type));
 
-        size_t vector_size = 0UL;
-        ib >> vector_size;
-        _dep_ids.resize(vector_size);
-        for (auto& el : _dep_ids) {
-            ib >> el;
-        }
+    std::set<primitive_id> _node_mem_deps;
+    ib >> _node_mem_deps;
 
-        ib >> vector_size;
-        _exec_dep_ids.resize(vector_size);
-        for (auto& el : _exec_dep_ids) {
-            ib >> el;
-        }
+    size_t vector_size = 0UL;
+    ib >> vector_size;
+    _dep_ids.resize(vector_size);
+    for (auto& el : _dep_ids) {
+        ib >> el;
+    }
 
-        _outputs[0] = nullptr;
-        if (!_mem_allocated) {
-            if (can_be_optimized() && type() != cldnn::concatenation::type_id())
-                _outputs[0] = get_network().get_engine().reinterpret_buffer(get_network().get_primitive(_dep_ids[0])->output_memory(), output_layout);
+    ib >> vector_size;
+    _exec_dep_ids.resize(vector_size);
+    for (auto& el : _exec_dep_ids) {
+        ib >> el;
+    }
+
+    _outputs[0] = nullptr;
+    if (!_mem_allocated) {
+        std::string dep_id;
+        ib >> dep_id;
+        if (dep_id.compare("NOT_FOUND") != 0) {
+            _outputs[0] = get_network().get_engine().reinterpret_buffer(get_network().get_primitive(dep_id)->output_memory(), output_layout);
+        } else if (type() == cldnn::mutable_data::type_id()) {
+            _outputs[0] = get_network().get_engine().allocate_memory(output_layout, _allocation_type);
+        }
+    } else {
+        if ((!can_share_buffer()) || can_be_optimized() || is_output()) {
+            _outputs[0] = get_network().get_engine().allocate_memory(output_layout, _allocation_type);
         } else {
-            if ((!can_share_buffer()) || can_be_optimized() || is_output()) {
-                _outputs[0] = get_network().get_engine().allocate_memory(output_layout, _allocation_type);
-            } else {
-                _outputs[0] = get_network().get_memory_pool().get_memory(output_layout, id(), get_network_id(), _node_mem_deps, _allocation_type, true);
-            }
+            _outputs[0] = get_network().get_memory_pool().get_memory(output_layout, id(), get_network_id(), _node_mem_deps, _allocation_type, true);
         }
-        _output_changed = false;
+    }
+    _output_changed = false;
 
-        ib >> vector_size;
-        _intermediates_memory.resize(vector_size);
-        for (size_t i = 0; i < vector_size; i++) {
-            layout ibuf_layout = layout(cldnn::data_types::bin, cldnn::format::any, cldnn::tensor());
-            ib >> ibuf_layout;
-            allocation_type _allocation_type;
-            ib >> make_data(&_allocation_type, sizeof(_allocation_type));
+    ib >> vector_size;
+    _intermediates_memory.resize(vector_size);
+    for (size_t i = 0; i < vector_size; i++) {
+        layout ibuf_layout = layout();
+        ib >> ibuf_layout;
+        allocation_type _allocation_type;
+        ib >> make_data(&_allocation_type, sizeof(_allocation_type));
 
-            _intermediates_memory[i] = get_network().get_engine().allocate_memory(ibuf_layout, _allocation_type);
-        }
+        _intermediates_memory[i] = get_network().get_engine().allocate_memory(ibuf_layout, _allocation_type);
     }
 }
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/prior_box.cpp b/src/plugins/intel_gpu/src/graph/prior_box.cpp
index 3a1571a029d4b7..50b6f7e643a16d 100644
--- a/src/plugins/intel_gpu/src/graph/prior_box.cpp
+++ b/src/plugins/intel_gpu/src/graph/prior_box.cpp
@@ -14,10 +14,7 @@
 #include <algorithm>
 
 namespace cldnn {
-primitive_type_id prior_box::type_id() {
-    static primitive_type_base<prior_box> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(prior_box)
 
 namespace {
 template <typename dtype>
diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp
index a29199f2249bd7..add4e18ad72221 100644
--- a/src/plugins/intel_gpu/src/graph/program.cpp
+++ b/src/plugins/intel_gpu/src/graph/program.cpp
@@ -763,8 +763,7 @@ void program::cleanup() {
         }
     }
 
-    if (_engine.configuration().kernels_cache_path.empty())
-        _kernels_cache->reset();
+    _kernels_cache->reset();
 }
 
 void program::add_split_outputs() {
diff --git a/src/plugins/intel_gpu/src/graph/proposal.cpp b/src/plugins/intel_gpu/src/graph/proposal.cpp
index 93b07b2a15ef01..c8a6e4b5de6530 100644
--- a/src/plugins/intel_gpu/src/graph/proposal.cpp
+++ b/src/plugins/intel_gpu/src/graph/proposal.cpp
@@ -20,10 +20,7 @@ static void generate_anchors(unsigned base_size,
                              bool shift_anchors,
                              bool round_ratios);
 
-primitive_type_id proposal::type_id() {
-    static primitive_type_base<proposal> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(proposal)
 
 layout proposal_inst::calc_output_layout(proposal_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/pyramid_roi_align.cpp b/src/plugins/intel_gpu/src/graph/pyramid_roi_align.cpp
index a7c83e428b0b96..4a20c26d490fd9 100644
--- a/src/plugins/intel_gpu/src/graph/pyramid_roi_align.cpp
+++ b/src/plugins/intel_gpu/src/graph/pyramid_roi_align.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id pyramid_roi_align::type_id() {
-    static primitive_type_base<pyramid_roi_align> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(pyramid_roi_align)
 
 layout pyramid_roi_align_inst::calc_output_layout(pyramid_roi_align_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/quantize.cpp b/src/plugins/intel_gpu/src/graph/quantize.cpp
index 9217e849fd824b..fb49cbf11566f5 100644
--- a/src/plugins/intel_gpu/src/graph/quantize.cpp
+++ b/src/plugins/intel_gpu/src/graph/quantize.cpp
@@ -12,10 +12,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id quantize::type_id() {
-    static primitive_type_base<quantize> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(quantize)
 
 layout quantize_inst::calc_output_layout(quantize_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<quantize>();
diff --git a/src/plugins/intel_gpu/src/graph/random_uniform.cpp b/src/plugins/intel_gpu/src/graph/random_uniform.cpp
index 29da8ad624531c..29603cab7b6a8c 100644
--- a/src/plugins/intel_gpu/src/graph/random_uniform.cpp
+++ b/src/plugins/intel_gpu/src/graph/random_uniform.cpp
@@ -9,11 +9,7 @@
 #include <data_inst.h>
 
 namespace cldnn {
-
-primitive_type_id random_uniform::type_id() {
-    static primitive_type_base<random_uniform> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(random_uniform)
 
 random_uniform_inst::typed_primitive_inst(network& network, random_uniform_node const &node)
 : parent(network, node) {
diff --git a/src/plugins/intel_gpu/src/graph/range.cpp b/src/plugins/intel_gpu/src/graph/range.cpp
index 4706fe901a0aa2..86459ebb0dd020 100644
--- a/src/plugins/intel_gpu/src/graph/range.cpp
+++ b/src/plugins/intel_gpu/src/graph/range.cpp
@@ -18,10 +18,7 @@ std::string lexical_cast(const json_base& j, int offset = 1) {
 }
 }  // namespace
 
-primitive_type_id range::type_id() {
-    static primitive_type_base<range> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(range)
 
 layout range_inst::calc_output_layout(range_node const& node, kernel_impl_params const& impl_param) {
     return impl_param.typed_desc<range>()->output_layout;
diff --git a/src/plugins/intel_gpu/src/graph/read_value.cpp b/src/plugins/intel_gpu/src/graph/read_value.cpp
index f74af539a1b5f8..bcced0f3a542e1 100644
--- a/src/plugins/intel_gpu/src/graph/read_value.cpp
+++ b/src/plugins/intel_gpu/src/graph/read_value.cpp
@@ -9,11 +9,7 @@
 #include <data_inst.h>
 
 namespace cldnn {
-
-primitive_type_id read_value::type_id() {
-    static primitive_type_base<read_value> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(read_value)
 
 read_value_inst::typed_primitive_inst(network& network, const read_value_node& node) :
     parent(network, node, false),
diff --git a/src/plugins/intel_gpu/src/graph/reduce.cpp b/src/plugins/intel_gpu/src/graph/reduce.cpp
index 21e748012f09f9..a063c06a159bf6 100644
--- a/src/plugins/intel_gpu/src/graph/reduce.cpp
+++ b/src/plugins/intel_gpu/src/graph/reduce.cpp
@@ -14,10 +14,7 @@
 #include "reduce_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id reduce::type_id() {
-    static primitive_type_base<reduce> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reduce)
 
 static std::vector<uint16_t> convert_axes(std::vector<int64_t> axes, size_t rank) {
     std::vector<uint16_t> converted_axes;
diff --git a/src/plugins/intel_gpu/src/graph/region_yolo.cpp b/src/plugins/intel_gpu/src/graph/region_yolo.cpp
index 24fc23bcda59bd..b470eccd526f3d 100644
--- a/src/plugins/intel_gpu/src/graph/region_yolo.cpp
+++ b/src/plugins/intel_gpu/src/graph/region_yolo.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id region_yolo::type_id() {
-    static primitive_type_base<region_yolo> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(region_yolo)
 
 layout region_yolo_inst::calc_output_layout(region_yolo_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/reorder.cpp b/src/plugins/intel_gpu/src/graph/reorder.cpp
index ed1c0beafa6619..b4820b0865dc74 100644
--- a/src/plugins/intel_gpu/src/graph/reorder.cpp
+++ b/src/plugins/intel_gpu/src/graph/reorder.cpp
@@ -14,11 +14,7 @@
 #include <string>
 
 namespace cldnn {
-
-primitive_type_id reorder::type_id() {
-    static primitive_type_base<reorder> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reorder)
 
 layout reorder_inst::calc_output_layout(reorder_node const& node, kernel_impl_params const& impl_param) {
     auto input_layout = impl_param.get_input_layout();
@@ -254,7 +250,8 @@ void reorder_inst::update_output_memory() {
     if (static_cast<bool>(_outputs[0]) && _network.get_engine().is_the_same_buffer(output_memory(), input_memory()))
         return;
 
-    build_deps();
+    if (_node != nullptr)
+        build_deps();
 
     if (requires_reinterpret()) {
         _outputs[0] = _network.get_engine().reinterpret_buffer(input_memory(), get_output_layout());
diff --git a/src/plugins/intel_gpu/src/graph/reorg_yolo.cpp b/src/plugins/intel_gpu/src/graph/reorg_yolo.cpp
index 0053a56a9eb34c..939386fc4c8784 100644
--- a/src/plugins/intel_gpu/src/graph/reorg_yolo.cpp
+++ b/src/plugins/intel_gpu/src/graph/reorg_yolo.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id reorg_yolo::type_id() {
-    static primitive_type_base<reorg_yolo> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reorg_yolo)
 
 layout reorg_yolo_inst::calc_output_layout(reorg_yolo_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/resample.cpp b/src/plugins/intel_gpu/src/graph/resample.cpp
index f1dab6fe524f78..27061cf1080782 100644
--- a/src/plugins/intel_gpu/src/graph/resample.cpp
+++ b/src/plugins/intel_gpu/src/graph/resample.cpp
@@ -12,10 +12,7 @@
 #include "interpolate_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id resample::type_id() {
-    static primitive_type_base<resample> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(resample)
 
 layout resample_inst::calc_output_layout(resample_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<resample>();
diff --git a/src/plugins/intel_gpu/src/graph/reshape.cpp b/src/plugins/intel_gpu/src/graph/reshape.cpp
index ed412c2fae32ce..06d25e9b29de9b 100644
--- a/src/plugins/intel_gpu/src/graph/reshape.cpp
+++ b/src/plugins/intel_gpu/src/graph/reshape.cpp
@@ -15,11 +15,7 @@
 #include "unsqueeze_shape_inference.hpp"
 
 namespace cldnn {
-
-primitive_type_id reshape::type_id() {
-    static primitive_type_base<reshape> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reshape)
 
 layout reshape_inst::calc_output_layout(reshape_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/reverse.cpp b/src/plugins/intel_gpu/src/graph/reverse.cpp
index e981a15bc6ba8a..11388ecadb4f11 100644
--- a/src/plugins/intel_gpu/src/graph/reverse.cpp
+++ b/src/plugins/intel_gpu/src/graph/reverse.cpp
@@ -9,10 +9,7 @@
 #include "reverse_inst.h"
 
 namespace cldnn {
-primitive_type_id reverse::type_id() {
-    static primitive_type_base<reverse> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reverse)
 
 layout reverse_inst::calc_output_layout(reverse_node const& node, kernel_impl_params const& impl_param) {
     return impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/reverse_sequence.cpp b/src/plugins/intel_gpu/src/graph/reverse_sequence.cpp
index f8f5eefec13e8b..cbb99ebed30078 100644
--- a/src/plugins/intel_gpu/src/graph/reverse_sequence.cpp
+++ b/src/plugins/intel_gpu/src/graph/reverse_sequence.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id reverse_sequence::type_id() {
-    static primitive_type_base<reverse_sequence> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(reverse_sequence)
 
 layout reverse_sequence_inst::calc_output_layout(reverse_sequence_node const& node, kernel_impl_params const& impl_param) {
     auto input_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/roi_align.cpp b/src/plugins/intel_gpu/src/graph/roi_align.cpp
index 8d4cb4561fedc0..2ae803582552c8 100644
--- a/src/plugins/intel_gpu/src/graph/roi_align.cpp
+++ b/src/plugins/intel_gpu/src/graph/roi_align.cpp
@@ -9,11 +9,7 @@
 #include "openvino/core/enum_names.hpp"
 
 namespace cldnn {
-
-primitive_type_id roi_align::type_id() {
-    static primitive_type_base<roi_align> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(roi_align)
 
 roi_align_inst::typed_primitive_inst(network& network, roi_align_node const& node)
     : parent(network, node) {}
diff --git a/src/plugins/intel_gpu/src/graph/roi_pooling.cpp b/src/plugins/intel_gpu/src/graph/roi_pooling.cpp
index e5684408cbb2ba..c64146fc1d1d7d 100644
--- a/src/plugins/intel_gpu/src/graph/roi_pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/roi_pooling.cpp
@@ -9,10 +9,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id roi_pooling::type_id() {
-    static primitive_type_base<roi_pooling> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(roi_pooling)
 
 layout roi_pooling_inst::calc_output_layout(roi_pooling_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/roll.cpp b/src/plugins/intel_gpu/src/graph/roll.cpp
index fa64d0d2bb421a..e42c3302c5c080 100644
--- a/src/plugins/intel_gpu/src/graph/roll.cpp
+++ b/src/plugins/intel_gpu/src/graph/roll.cpp
@@ -9,11 +9,7 @@
 #include "roll_inst.hpp"
 
 namespace cldnn {
-
-primitive_type_id roll::type_id() {
-    static primitive_type_base<roll> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(roll)
 
 layout roll_inst::calc_output_layout(const roll_node& node, kernel_impl_params const& impl_param) {
     return impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/scatter_elements_update.cpp b/src/plugins/intel_gpu/src/graph/scatter_elements_update.cpp
index 06b3d23fd40d55..cd60b1539ba46a 100644
--- a/src/plugins/intel_gpu/src/graph/scatter_elements_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/scatter_elements_update.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id scatter_elements_update::type_id() {
-    static primitive_type_base<scatter_elements_update> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(scatter_elements_update)
 
 layout scatter_elements_update_inst::calc_output_layout(scatter_elements_update_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<scatter_elements_update>();
diff --git a/src/plugins/intel_gpu/src/graph/scatter_nd_update.cpp b/src/plugins/intel_gpu/src/graph/scatter_nd_update.cpp
index b54b9c61d09fb9..c9ae82a5ba2c4b 100644
--- a/src/plugins/intel_gpu/src/graph/scatter_nd_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/scatter_nd_update.cpp
@@ -10,11 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id scatter_nd_update::type_id() {
-    static primitive_type_base<scatter_nd_update> instance;
-    return &instance;
-}
-
+GPU_DEFINE_PRIMITIVE_TYPE_ID(scatter_nd_update)
 
 layout scatter_nd_update_inst::calc_output_layout(scatter_nd_update_node const& node, kernel_impl_params const& impl_param) {
     auto input_layout = impl_param.get_input_layout();
diff --git a/src/plugins/intel_gpu/src/graph/scatter_update.cpp b/src/plugins/intel_gpu/src/graph/scatter_update.cpp
index c4fc63a191730a..1b72ab9ca2355f 100644
--- a/src/plugins/intel_gpu/src/graph/scatter_update.cpp
+++ b/src/plugins/intel_gpu/src/graph/scatter_update.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id scatter_update::type_id() {
-    static primitive_type_base<scatter_update> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(scatter_update)
 
 layout scatter_update_inst::calc_output_layout(scatter_update_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<scatter_update>();
diff --git a/src/plugins/intel_gpu/src/graph/select.cpp b/src/plugins/intel_gpu/src/graph/select.cpp
index d58b9080822147..9d46fa91e63c11 100644
--- a/src/plugins/intel_gpu/src/graph/select.cpp
+++ b/src/plugins/intel_gpu/src/graph/select.cpp
@@ -12,10 +12,7 @@
 #include "select_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id select::type_id() {
-    static primitive_type_base<select> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(select)
 
 layout select_inst::calc_output_layout(select_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/shape_of.cpp b/src/plugins/intel_gpu/src/graph/shape_of.cpp
index 849b60c704d25a..3098f91a329766 100644
--- a/src/plugins/intel_gpu/src/graph/shape_of.cpp
+++ b/src/plugins/intel_gpu/src/graph/shape_of.cpp
@@ -11,10 +11,7 @@
 #include <vector>
 
 namespace cldnn {
-primitive_type_id shape_of::type_id() {
-    static primitive_type_base<shape_of> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(shape_of)
 
 layout shape_of_inst::calc_output_layout(shape_of_node const& node, kernel_impl_params const& impl_param) {
     auto prim = impl_param.typed_desc<shape_of>();
diff --git a/src/plugins/intel_gpu/src/graph/shuffle_channels.cpp b/src/plugins/intel_gpu/src/graph/shuffle_channels.cpp
index 8a26d30b451d14..8444c299608e36 100644
--- a/src/plugins/intel_gpu/src/graph/shuffle_channels.cpp
+++ b/src/plugins/intel_gpu/src/graph/shuffle_channels.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id shuffle_channels::type_id() {
-    static primitive_type_base<shuffle_channels> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(shuffle_channels)
 
 layout shuffle_channels_inst::calc_output_layout(shuffle_channels_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<shuffle_channels>();
diff --git a/src/plugins/intel_gpu/src/graph/slice.cpp b/src/plugins/intel_gpu/src/graph/slice.cpp
index 591edb58fa92f3..7192832a1511c6 100644
--- a/src/plugins/intel_gpu/src/graph/slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/slice.cpp
@@ -8,11 +8,7 @@
 #include <json_object.h>
 
 namespace cldnn {
-
-primitive_type_id slice::type_id() {
-    static primitive_type_base<slice> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(slice)
 
 slice_inst::typed_primitive_inst(network& network, slice_node const& node)
     : parent(network, node) {}
diff --git a/src/plugins/intel_gpu/src/graph/softmax.cpp b/src/plugins/intel_gpu/src/graph/softmax.cpp
index 658b60ccfec752..50be812bb6b2bd 100644
--- a/src/plugins/intel_gpu/src/graph/softmax.cpp
+++ b/src/plugins/intel_gpu/src/graph/softmax.cpp
@@ -8,10 +8,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id softmax::type_id() {
-    static primitive_type_base<softmax> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(softmax)
 
 layout softmax_inst::calc_output_layout(softmax_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/space_to_batch.cpp b/src/plugins/intel_gpu/src/graph/space_to_batch.cpp
index 64844d455847bc..15134a37eb0d47 100644
--- a/src/plugins/intel_gpu/src/graph/space_to_batch.cpp
+++ b/src/plugins/intel_gpu/src/graph/space_to_batch.cpp
@@ -12,10 +12,7 @@
 #include <vector>
 
 namespace cldnn {
-primitive_type_id cldnn::space_to_batch::type_id() {
-    static primitive_type_base<space_to_batch> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(space_to_batch)
 
 layout space_to_batch_inst::calc_output_layout(space_to_batch_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<space_to_batch>();
diff --git a/src/plugins/intel_gpu/src/graph/space_to_depth.cpp b/src/plugins/intel_gpu/src/graph/space_to_depth.cpp
index a77bf4573c06e0..b171e24a7d7458 100644
--- a/src/plugins/intel_gpu/src/graph/space_to_depth.cpp
+++ b/src/plugins/intel_gpu/src/graph/space_to_depth.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id space_to_depth::type_id() {
-    static primitive_type_base<space_to_depth> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(space_to_depth)
 
 layout space_to_depth_inst::calc_output_layout(space_to_depth_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<space_to_depth>();
diff --git a/src/plugins/intel_gpu/src/graph/split.cpp b/src/plugins/intel_gpu/src/graph/split.cpp
index 0555d6f89a45bb..70498abe6c8778 100644
--- a/src/plugins/intel_gpu/src/graph/split.cpp
+++ b/src/plugins/intel_gpu/src/graph/split.cpp
@@ -10,10 +10,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id split::type_id() {
-    static primitive_type_base<split> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(split)
 
 layout split_inst::calc_output_layout(split_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/graph/strided_slice.cpp b/src/plugins/intel_gpu/src/graph/strided_slice.cpp
index 82e2b5a15bf890..341e22ead86490 100644
--- a/src/plugins/intel_gpu/src/graph/strided_slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/strided_slice.cpp
@@ -13,10 +13,7 @@
 #include "strided_slice_shape_inference.hpp"
 
 namespace cldnn {
-primitive_type_id strided_slice::type_id() {
-    static primitive_type_base<strided_slice> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(strided_slice)
 
 layout strided_slice_inst::calc_output_layout(strided_slice_node const& node, kernel_impl_params const& impl_param) {
     auto desc = impl_param.typed_desc<strided_slice>();
diff --git a/src/plugins/intel_gpu/src/graph/tile.cpp b/src/plugins/intel_gpu/src/graph/tile.cpp
index 10445becc1325d..da6e556a5aa623 100644
--- a/src/plugins/intel_gpu/src/graph/tile.cpp
+++ b/src/plugins/intel_gpu/src/graph/tile.cpp
@@ -13,10 +13,7 @@
 #include <string>
 
 namespace cldnn {
-primitive_type_id tile::type_id() {
-    static primitive_type_base<tile> instance;
-    return &instance;
-}
+GPU_DEFINE_PRIMITIVE_TYPE_ID(tile)
 
 layout tile_inst::calc_output_layout(tile_node const& node, kernel_impl_params const& impl_param) {
     assert(static_cast<bool>(impl_param.desc->output_data_type) == false &&
diff --git a/src/plugins/intel_gpu/src/plugin/compiled_model.cpp b/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
index 422f8533a3a0ed..c554a70fe3b5fb 100644
--- a/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
+++ b/src/plugins/intel_gpu/src/plugin/compiled_model.cpp
@@ -3,6 +3,8 @@
 //
 
 #include "ie_metric_helpers.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
 #include "intel_gpu/plugin/graph.hpp"
 #include "intel_gpu/plugin/itt.hpp"
 #include "intel_gpu/plugin/infer_request.hpp"
@@ -10,8 +12,6 @@
 #include "intel_gpu/plugin/async_infer_request.hpp"
 #include "intel_gpu/plugin/async_infer_request_legacy.hpp"
 #include "openvino/runtime/intel_gpu/properties.hpp"
-#include "serialization/binary_buffer.hpp"
-#include "serialization/string_serializer.hpp"
 
 #include <description_buffer.hpp>
 #include <threading/ie_executor_manager.hpp>
@@ -342,7 +342,7 @@ IInferRequestInternal::Ptr CompiledModel::CreateInferRequest() {
                                                _callbackExecutor);
 }
 
-bool CompiledModel::isSerializable() {
+bool CompiledModel::is_serializable() {
     // Model with multiple graphs is not yet supported.
     if (m_graphs.size() != 1)
         return false;
@@ -354,12 +354,16 @@ bool CompiledModel::isSerializable() {
     return true;
 }
 
+// Cache blob format:
+//     [ ConstInputsDataMap / ConstOutputsDataMap ]
+//     [ ov::Node::Input/ ov::Node::Output ]
+//     [ ov::intel_gpu::Graph ]
 void CompiledModel::Export(std::ostream& networkModel) {
     OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "CompiledModel::Export");
     if (m_graphs.empty())
         IE_THROW(NetworkNotLoaded);
 
-    if (!isSerializable())
+    if (!is_serializable())
         return;
 
     cldnn::BinaryOutputBuffer ob(networkModel);
diff --git a/src/plugins/intel_gpu/src/plugin/graph.cpp b/src/plugins/intel_gpu/src/plugin/graph.cpp
index e6289b18bbb089..1ae2bc88c4617e 100644
--- a/src/plugins/intel_gpu/src/plugin/graph.cpp
+++ b/src/plugins/intel_gpu/src/plugin/graph.cpp
@@ -3,6 +3,11 @@
 //
 
 #include "intel_gpu/graph/network.hpp"
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
+#include "intel_gpu/graph/serialization/map_serializer.hpp"
+#include "intel_gpu/graph/serialization/layout_serializer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
+#include "intel_gpu/graph/serialization/vector_serializer.hpp"
 #include "intel_gpu/runtime/profiling.hpp"
 #include "intel_gpu/runtime/debug_configuration.hpp"
 
@@ -11,11 +16,6 @@
 #include <cldnn/cldnn_config.hpp>
 #include "intel_gpu/plugin/infer_request.hpp"
 #include "intel_gpu/plugin/itt.hpp"
-#include "serialization/binary_buffer.hpp"
-#include "serialization/map_serializer.hpp"
-#include "serialization/layout_serializer.hpp"
-#include "serialization/string_serializer.hpp"
-#include "serialization/vector_serializer.hpp"
 
 #include <description_buffer.hpp>
 #include <threading/ie_executor_manager.hpp>
@@ -468,6 +468,11 @@ std::shared_ptr<ngraph::Function> Graph::GetExecGraphInfoByPrimitivesInfo(std::v
     return std::make_shared<ngraph::Function>(results, params, "runtime_gpu_graph");
 }
 
+// Cache blob format:
+//     [ ov::intel_gpu::Program::inputLayouts ]
+//     [ ov::intel_gpu::Graph::primitiveIDs ]
+//     [ ov::intel_gpu::Graph::outputDims ]
+//     [ cldnn::network ]
 void Graph::Export(cldnn::BinaryOutputBuffer &ob) {
     ob << m_program->inputLayouts;
     ob << primitiveIDs;
diff --git a/src/plugins/intel_gpu/src/plugin/plugin.cpp b/src/plugins/intel_gpu/src/plugin/plugin.cpp
index aa13e12ed6cc6f..a2f6319788ae4d 100644
--- a/src/plugins/intel_gpu/src/plugin/plugin.cpp
+++ b/src/plugins/intel_gpu/src/plugin/plugin.cpp
@@ -580,6 +580,7 @@ Parameter Plugin::GetMetric(const std::string& name, const std::map<std::string,
             ov::PropertyName{ov::optimal_batch_size.name(), PropertyMutability::RO},
             ov::PropertyName{ov::max_batch_size.name(), PropertyMutability::RO},
             ov::PropertyName{ov::caching_properties.name(), PropertyMutability::RO},
+            ov::PropertyName{ov::device::architecture.name(), PropertyMutability::RO},
             ov::PropertyName{ov::device::full_name.name(), PropertyMutability::RO},
             ov::PropertyName{ov::device::uuid.name(), PropertyMutability::RO},
             ov::PropertyName{ov::device::type.name(), PropertyMutability::RO},
@@ -967,7 +968,23 @@ Parameter Plugin::GetMetric(const std::string& name, const std::map<std::string,
         IE_SET_METRIC_RETURN(IMPORT_EXPORT_SUPPORT, true);
     } else if (name == ov::caching_properties) {
         std::vector<ov::PropertyName> cachingProperties;
+        cachingProperties.push_back(ov::PropertyName(uarch_version.name(), PropertyMutability::RO));
+        cachingProperties.push_back(ov::PropertyName(execution_units_count.name(), PropertyMutability::RO));
+        cachingProperties.push_back(ov::PropertyName("GPU_DRIVER_VERSION", PropertyMutability::RO));
         return decltype(ov::caching_properties)::value_type(cachingProperties);
+    } else if (name == "GPU_DRIVER_VERSION") {
+        return device_info.driver_version;
+    } else if (name == ov::device::architecture) {
+        std::stringstream s;
+        s << "GPU.";
+        if (device_info.gfx_ver.major == 0 && device_info.gfx_ver.minor == 0) {
+            s << device_info.dev_name;
+        } else {
+            s << static_cast<int>(device_info.gfx_ver.major) << "."
+              << static_cast<int>(device_info.gfx_ver.minor) << "."
+              << static_cast<int>(device_info.gfx_ver.revision);
+        }
+        return decltype(ov::device::architecture)::value_type {s.str()};
     } else {
         IE_THROW() << "Unsupported metric key " << name;
     }
diff --git a/src/plugins/intel_gpu/src/runtime/CMakeLists.txt b/src/plugins/intel_gpu/src/runtime/CMakeLists.txt
index 294f6ad0fef2fb..7fe9656aea085e 100644
--- a/src/plugins/intel_gpu/src/runtime/CMakeLists.txt
+++ b/src/plugins/intel_gpu/src/runtime/CMakeLists.txt
@@ -29,8 +29,7 @@ endif()
 
 target_include_directories(${TARGET_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<BUILD_INTERFACE:${INCLUDE_DIR}>
-    $<BUILD_INTERFACE:${MAIN_DIR}/src/graph/include>)
+    $<BUILD_INTERFACE:${INCLUDE_DIR}>)
     
 target_compile_options(${TARGET_NAME} PRIVATE
   $<$<CONFIG:Release>:$<IF:$<CXX_COMPILER_ID:MSVC>,/Os,-Os>>)
diff --git a/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp b/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp
index 4b05d74318c676..4c630ee07ba807 100644
--- a/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp
+++ b/src/plugins/intel_gpu/src/runtime/kernels_cache.cpp
@@ -7,12 +7,12 @@
 #include "ocl/ocl_kernel.hpp"
 #include "ocl/ocl_engine.hpp"
 #include "ocl/ocl_common.hpp"
+#include "intel_gpu/graph/serialization/set_serializer.hpp"
+#include "intel_gpu/graph/serialization/vector_serializer.hpp"
+#include "intel_gpu/graph/serialization/map_serializer.hpp"
+#include "intel_gpu/graph/serialization/string_serializer.hpp"
 #include "intel_gpu/runtime/debug_configuration.hpp"
 #include "openvino/util/file_util.hpp"
-#include "serialization/set_serializer.hpp"
-#include "serialization/vector_serializer.hpp"
-#include "serialization/map_serializer.hpp"
-#include "serialization/string_serializer.hpp"
 
 #include <algorithm>
 #include <cassert>
@@ -447,6 +447,15 @@ std::vector<kernel_id> kernels_cache::add_kernels_source(std::vector<std::shared
     return kernel_ids;
 }
 
+void kernels_cache::add_kernels(const std::vector<std::string>& kernel_ids, const std::vector<kernel::ptr>& kernels) {
+    OPENVINO_ASSERT(kernel_ids.size() == kernels.size(), "[GPU] The sizes of kernel_ids and kernels are different.");
+
+    for (size_t i = 0; i < kernel_ids.size(); i++) {
+        const auto& kmap = std::make_pair(kernel_ids[i], kernels[i]);
+        _kernels.insert(kmap);
+    }
+}
+
 void kernels_cache::compile() {
     OV_ITT_SCOPED_TASK(itt::domains::CLDNN, "KernelsCache::BuildAll");
 
@@ -477,10 +486,7 @@ void kernels_cache::compile() {
 #endif
 }
 void kernels_cache::save(BinaryOutputBuffer& ob) const {
-    OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] not supported engine type");
-
-    ob << _prog_id;
-    ob << batch_header_str;
+    OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] Not supported engine type");
 
     std::map<std::string, std::string> entry_point_to_id;
     for (auto iter = _kernels.begin(); iter != _kernels.end(); iter++) {
@@ -534,7 +540,7 @@ void kernels_cache::save(BinaryOutputBuffer& ob) const {
 }
 
 void kernels_cache::load(BinaryInputBuffer& ib) {
-    OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] not supported engine type");
+    OPENVINO_ASSERT(_engine.type() == engine_types::ocl, "[GPU] Not supported engine type");
 
     std::unique_ptr<ocl::ocl_engine> build_engine =
         cldnn::make_unique<ocl::ocl_engine>(_engine.get_device(), runtime_types::ocl, _engine.configuration(), _engine.get_task_executor());
@@ -562,8 +568,6 @@ void kernels_cache::load(BinaryInputBuffer& ib) {
                     cl_context cl_context = build_engine->get_cl_context().get();
                     kernel::ptr kernel = kernels_factory::create(_engine, cl_context, cl_kernel, entry_point);
                     _kernels.insert({k_id->second, kernel});
-                } else {
-                    throw std::runtime_error("Could not find entry point");
                 }
             }
         }
diff --git a/src/plugins/intel_gpu/src/runtime/kernels_cache.hpp b/src/plugins/intel_gpu/src/runtime/kernels_cache.hpp
index 1aea4775a8edc5..b8756f270fcb2d 100644
--- a/src/plugins/intel_gpu/src/runtime/kernels_cache.hpp
+++ b/src/plugins/intel_gpu/src/runtime/kernels_cache.hpp
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "intel_gpu/graph/serialization/binary_buffer.hpp"
 #include "intel_gpu/runtime/engine.hpp"
 #include "intel_gpu/runtime/kernel.hpp"
 
@@ -18,7 +19,6 @@
 #include <threading/ie_cpu_streams_executor.hpp>
 #include "kernels_factory.hpp"
 #include "ocl/ocl_engine.hpp"
-#include "serialization/binary_buffer.hpp"
 
 namespace cldnn {
 class kernels_cache {
@@ -108,6 +108,7 @@ class kernels_cache {
         _kernels.erase(id);
     }
     std::vector<kernel_id> add_kernels_source(std::vector<std::shared_ptr<kernel_string>> kernel_sources, bool dump_custom_program = false);
+    void add_kernels(const std::vector<std::string>& kernel_ids, const std::vector<kernel::ptr>& kernels);
     void compile();
     void save(BinaryOutputBuffer& ob) const;
     void load(BinaryInputBuffer& ib);
diff --git a/src/plugins/intel_gpu/tests/test_cases/activation_simple_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/activation_simple_gpu_test.cpp
index a2deda0ae69ccc..4bbed5bb28c421 100644
--- a/src/plugins/intel_gpu/tests/test_cases/activation_simple_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/activation_simple_gpu_test.cpp
@@ -1504,7 +1504,8 @@ using activation_random_test_params = std::tuple<data_types,
                                                  tensor,                        // input_size
                                                  activation_func,               // func_type
                                                  activation_additional_params,  // additional_params
-                                                 padding>;
+                                                 padding,
+                                                 bool>;
 
 struct activation_random_test : testing::TestWithParam<activation_random_test_params>
 {
@@ -1604,7 +1605,8 @@ struct activation_random_test : testing::TestWithParam<activation_random_test_pa
         activation_func func_type;
         activation_additional_params additional_params;
         padding padd;
-        std::tie(input_type, input_format, input_size, func_type, additional_params, padd) = params;
+        bool is_caching_test;
+        std::tie(input_type, input_format, input_size, func_type, additional_params, padd, is_caching_test) = params;
         auto in_layout = layout(input_type, format::bfyx, input_size);
 
         auto in_mem = engine.allocate_memory(in_layout);
@@ -1620,11 +1622,29 @@ struct activation_random_test : testing::TestWithParam<activation_random_test_pa
         auto build_opts = build_options();
         build_opts.set_option(build_option::outputs({"activation"}));
 
-        network net(engine, topo, build_opts);
-        net.set_input_data("in", in_mem);
+        std::shared_ptr<cldnn::network> net;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topo, build_opts);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                net = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            net = std::make_shared<cldnn::network>(engine, topo, build_opts);
+        }
+
+        net->set_input_data("in", in_mem);
 
         // first execution of ref
-        auto result = net.execute();
+        auto result = net->execute();
         auto output = result.at("activation").get_memory();
 
         cldnn::topology topo_opt;
@@ -1675,11 +1695,11 @@ TEST_P(activation_random_test, random) {
 }
 
 const auto reluParams = testing::ValuesIn(std::vector<activation_random_test_params>{
-    {data_types::i8, format::b_fs_yx_fsv32, {1, 32, 5, 5}, activation_func::relu, {}, {}},
-    {data_types::i8, format::bs_fs_yx_bsv32_fsv32, {32, 32, 5, 5}, activation_func::relu, {}, {}},
-    {data_types::f16, format::bs_fs_yx_bsv32_fsv16, {32, 32, 5, 5}, activation_func::relu, {}, {}},
-    {data_types::i8, format::bs_fs_yx_bsv32_fsv32, {16, 16, 5, 5}, activation_func::relu, {}, {}},
-    {data_types::f16, format::bs_fs_yx_bsv32_fsv16, {16, 16, 5, 5}, activation_func::relu, {}, {}},
+    {data_types::i8, format::b_fs_yx_fsv32, {1, 32, 5, 5}, activation_func::relu, {}, {}, false},
+    {data_types::i8, format::bs_fs_yx_bsv32_fsv32, {32, 32, 5, 5}, activation_func::relu, {}, {}, false},
+    {data_types::f16, format::bs_fs_yx_bsv32_fsv16, {32, 32, 5, 5}, activation_func::relu, {}, {}, false},
+    {data_types::i8, format::bs_fs_yx_bsv32_fsv32, {16, 16, 5, 5}, activation_func::relu, {}, {}, false},
+    {data_types::f16, format::bs_fs_yx_bsv32_fsv16, {16, 16, 5, 5}, activation_func::relu, {}, {}, false},
 });
 
 INSTANTIATE_TEST_SUITE_P(relu_activation_blocked_tests, activation_random_test, reluParams);
@@ -1752,7 +1772,8 @@ INSTANTIATE_TEST_SUITE_P(
                        ::testing::Values(inputShapes[0]),
                        ::testing::ValuesIn(activationFunctions),
                        ::testing::Values(activation_additional_params{}),
-                       ::testing::Values(padding{})));
+                       ::testing::Values(padding{}),
+                       ::testing::Values(false)));
 INSTANTIATE_TEST_SUITE_P(
     fp_activation_blocked_tests1,
     activation_random_test,
@@ -1761,7 +1782,8 @@ INSTANTIATE_TEST_SUITE_P(
                        ::testing::Values(inputShapes[2]),
                        ::testing::ValuesIn(activationFunctions),
                        ::testing::Values(activation_additional_params{}),
-                       ::testing::Values(padding{})));
+                       ::testing::Values(padding{}),
+                       ::testing::Values(false)));
 INSTANTIATE_TEST_SUITE_P(
     fp_activation_blocked_tests2,
     activation_random_test,
@@ -1770,7 +1792,8 @@ INSTANTIATE_TEST_SUITE_P(
                        ::testing::Values(inputShapes[1]),
                        ::testing::ValuesIn(activationFunctions),
                        ::testing::Values(activation_additional_params{}),
-                       ::testing::Values(padding{})));
+                       ::testing::Values(padding{}),
+                       ::testing::Values(false)));
 INSTANTIATE_TEST_SUITE_P(
     fp_activation_blocked_tests3,
     activation_random_test,
@@ -1779,7 +1802,8 @@ INSTANTIATE_TEST_SUITE_P(
                        ::testing::ValuesIn(inputShapes),
                        ::testing::Values(activationFunctions.front()),
                        ::testing::Values(activation_additional_params{}),
-                       ::testing::Values(padding{})));
+                       ::testing::Values(padding{}),
+                       ::testing::Values(false)));
 INSTANTIATE_TEST_SUITE_P(
     fp_activation_blocked_tests4,
     activation_random_test,
@@ -1788,4 +1812,15 @@ INSTANTIATE_TEST_SUITE_P(
                        ::testing::ValuesIn(inputShapes),
                        ::testing::Values(activationFunctions.back()),
                        ::testing::Values(activation_additional_params{}),
-                       ::testing::Values(padding{})));
+                       ::testing::Values(padding{}),
+                       ::testing::Values(false)));
+INSTANTIATE_TEST_SUITE_P(
+    export_import,
+    activation_random_test,
+    ::testing::Combine(::testing::Values(dataTypes[0]),
+                       ::testing::Values(types[0]),
+                       ::testing::Values(inputShapes[0]),
+                       ::testing::Values(activationFunctions.back()),
+                       ::testing::Values(activation_additional_params{}),
+                       ::testing::Values(padding{}),
+                       ::testing::Values(true)));
diff --git a/src/plugins/intel_gpu/tests/test_cases/adaptive_avg_pooling_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/adaptive_avg_pooling_gpu_test.cpp
index 6940f0962dec4e..2d37f9aa52e2bc 100644
--- a/src/plugins/intel_gpu/tests/test_cases/adaptive_avg_pooling_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/adaptive_avg_pooling_gpu_test.cpp
@@ -24,7 +24,8 @@ struct AdaptiveAvgPoolingParams {
 using AdaptiveAvgPoolingParamsWithLayout = std::tuple<
     AdaptiveAvgPoolingParams,
     format::type,   // source (plain) layout - bfyx or bfzyx
-    format::type    // target (blocked) layout
+    format::type,   // target (blocked) layout
+    bool            // is_caching_test
 >;
 
 const std::vector<format::type> layouts_2d = {
@@ -95,11 +96,13 @@ struct PrintToStringParamName {
         AdaptiveAvgPoolingParams p;
         format::type plain_layout;
         format::type target_layout;
-        std::tie(p, plain_layout, target_layout) = param.param;
+        bool is_caching_test;
+        std::tie(p, plain_layout, target_layout, is_caching_test) = param.param;
         buf << " input tensor " << p.inputTensor.to_string()
             << " output tensor " << p.outputTensor.to_string()
             << " plain layout " << plain_layout
-            << " target layout " << target_layout;
+            << " target layout " << target_layout
+            << " is_caching_test " << is_caching_test;
         return buf.str();
     }
 };
@@ -114,7 +117,8 @@ struct adaptive_avg_pooling_test
         AdaptiveAvgPoolingParams params;
         format::type plain_layout;
         format::type target_layout;
-        std::tie(params, plain_layout, target_layout) = this->GetParam();
+        bool is_caching_test;
+        std::tie(params, plain_layout, target_layout, is_caching_test) = this->GetParam();
 
         std::vector<T> input_data;
         std::vector<T> expected;
@@ -131,11 +135,28 @@ struct adaptive_avg_pooling_test
         topology.add(adaptive_pooling("adaptive_avg_pooling_blocked", "input_reordered", params.outputTensor));
         topology.add(reorder("adaptive_avg_pooling", "adaptive_avg_pooling_blocked", plain_layout, data_type));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
 
-        network.set_input_data("input", input);
+        network->set_input_data("input", input);
 
-        auto result = network.execute();
+        auto result = network->execute();
 
         auto out_mem = result.at("adaptive_avg_pooling").get_memory();
         cldnn::mem_lock<T> out_ptr(out_mem, get_test_stream());
@@ -169,7 +190,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f32_2d,
                                         { tensor(2, 3, 7, 3), tensor(2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::Values(format::bfyx)),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f32_3d,
@@ -180,7 +202,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f32_3d,
                                         { tensor(2, 2, 8, 5, 4), tensor(2, 2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::Values(format::bfzyx)),
+                                 ::testing::Values(format::bfzyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f16_2d,
@@ -191,7 +214,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f16_2d,
                                         { tensor(2, 3, 7, 3), tensor(2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::Values(format::bfyx)),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f16_3d,
@@ -202,7 +226,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_f16_3d,
                                         { tensor(2, 2, 8, 5, 4), tensor(2, 2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::Values(format::bfzyx)),
+                                 ::testing::Values(format::bfzyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_2d_all_formats,
@@ -213,7 +238,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_2d_all_formats,
                                         { tensor(32, 32, 7, 3), tensor(32, 32, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::ValuesIn(layouts_2d)),
+                                 ::testing::ValuesIn(layouts_2d),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_3d_all_formats,
@@ -224,5 +250,17 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_avg_pooling_test_3d_all_formats,
                                         { tensor(32, 32, 7, 3, 3), tensor(32, 32, 3, 3, 2) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::ValuesIn(layouts_3d)),
+                                 ::testing::ValuesIn(layouts_3d),
+                                 ::testing::Values(false)),
+                         PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         adaptive_avg_pooling_test_f16,
+                         ::testing::Combine(
+                                 ::testing::ValuesIn(std::vector<AdaptiveAvgPoolingParams>{
+                                        { tensor(1, 2, 7, 3), tensor(1, 2, 3, 3) },
+                                    }),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(true)),
                          PrintToStringParamName());
diff --git a/src/plugins/intel_gpu/tests/test_cases/adaptive_max_pooling_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/adaptive_max_pooling_gpu_test.cpp
index bb7d6860114662..78c272eb7e6cfd 100644
--- a/src/plugins/intel_gpu/tests/test_cases/adaptive_max_pooling_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/adaptive_max_pooling_gpu_test.cpp
@@ -26,7 +26,8 @@ struct AdaptiveMaxPoolingParams {
 using AdaptiveMaxPoolingParamsWithLayout = std::tuple<
     AdaptiveMaxPoolingParams,
     format::type,   // source (plain) layout - bfyx or bfzyx
-    format::type    // target (blocked) layout
+    format::type,   // target (blocked) layout
+    bool            // is_caching_test
 >;
 
 const std::vector<format::type> layouts_2d = {
@@ -100,11 +101,13 @@ struct PrintToStringParamName {
         AdaptiveMaxPoolingParams p;
         format::type plain_layout;
         format::type target_layout;
-        std::tie(p, plain_layout, target_layout) = param.param;
+        bool is_caching_test;
+        std::tie(p, plain_layout, target_layout, is_caching_test) = param.param;
         buf << " input tensor " << p.inputTensor.to_string()
             << " output tensor " << p.outputTensor.to_string()
             << " plain layout " << plain_layout
-            << " target layout " << target_layout;
+            << " target layout " << target_layout
+            << " is_caching_test " << is_caching_test;
         return buf.str();
     }
 };
@@ -119,7 +122,8 @@ struct adaptive_max_pooling_test
         AdaptiveMaxPoolingParams params;
         format::type plain_layout;
         format::type target_layout;
-        std::tie(params, plain_layout, target_layout) = this->GetParam();
+        bool is_caching_test;
+        std::tie(params, plain_layout, target_layout, is_caching_test) = this->GetParam();
         const bool need_reorder = target_layout != plain_layout;
 
         std::vector<T> input_data;
@@ -158,11 +162,29 @@ struct adaptive_max_pooling_test
             result_id = reorder_result_id;
         }
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
 
-        network.set_input_data(input_data_id, input_mem);
+        network->set_input_data(input_data_id, input_mem);
 
-        auto result = network.execute();
+        auto result = network->execute();
 
         auto out_mem = result.at(result_id).get_memory();
         cldnn::mem_lock<T> out_ptr(out_mem, get_test_stream());
@@ -174,6 +196,9 @@ struct adaptive_max_pooling_test
                 << "i = " << i << ", format=" << fmt_to_str(target_layout);
         }
 
+        if (is_caching_test)
+            return;
+
         const auto block_sizes = format::traits(target_layout).block_sizes;
         const auto index_offset = std::accumulate(block_sizes.begin(), block_sizes.end(), 1u,
                                                   [](size_t total, const std::pair<size_t, int>& b) {
@@ -222,7 +247,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f32_2d,
                                         { tensor(2, 3, 7, 3), tensor(2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::Values(format::bfyx)),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f32_3d,
@@ -233,7 +259,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f32_3d,
                                         { tensor(2, 2, 8, 5, 4), tensor(2, 2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::Values(format::bfzyx)),
+                                 ::testing::Values(format::bfzyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f16_2d,
@@ -244,7 +271,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f16_2d,
                                         { tensor(2, 3, 7, 3), tensor(2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::Values(format::bfyx)),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f16_3d,
@@ -255,7 +283,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_f16_3d,
                                         { tensor(2, 2, 8, 5, 4), tensor(2, 2, 3, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::Values(format::bfzyx)),
+                                 ::testing::Values(format::bfzyx),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_2d_all_formats,
@@ -266,7 +295,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_2d_all_formats,
                                         { tensor(32, 32, 7, 3), tensor(32, 32, 3, 3) },
                                     }),
                                  ::testing::Values(format::bfyx),
-                                 ::testing::ValuesIn(layouts_2d)),
+                                 ::testing::ValuesIn(layouts_2d),
+                                 ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_3d_all_formats,
@@ -277,5 +307,17 @@ INSTANTIATE_TEST_SUITE_P(smoke_adaptive_max_pooling_test_3d_all_formats,
                                         { tensor(32, 32, 7, 3, 3), tensor(32, 32, 3, 3, 2) },
                                     }),
                                  ::testing::Values(format::bfzyx),
-                                 ::testing::ValuesIn(layouts_3d)),
+                                 ::testing::ValuesIn(layouts_3d),
+                                 ::testing::Values(false)),
+                         PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         adaptive_max_pooling_test_f16,
+                         ::testing::Combine(
+                                 ::testing::ValuesIn(std::vector<AdaptiveMaxPoolingParams>{
+                                        { tensor(1, 2, 7, 3), tensor(1, 2, 3, 3) },
+                                    }),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(format::bfyx),
+                                 ::testing::Values(true)),
                          PrintToStringParamName());
diff --git a/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
index 1d1b7614d9ac78..cf1a574e113fcd 100644
--- a/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
@@ -107,7 +107,8 @@ void tile_ref(const memory::ptr input, memory::ptr output, int64_t axis, int num
     }
 }
 
-TEST(add_reorders_gpu, basic_reshape_and_tile) {
+template <typename T>
+void test_add_reorders_gpu_basic_reshape_and_tile(bool is_caching_test) {
     auto& engine = get_test_engine();
 
     auto input = engine.allocate_memory({ data_types::f32, format::byxf,{ 1, 2, 2, 1 } });
@@ -118,22 +119,48 @@ TEST(add_reorders_gpu, basic_reshape_and_tile) {
     topology.add(reshape("reshape", "input", tensor(2, 1, 2, 1)));
     topology.add(tile("tile", "reshape", std::vector<int64_t>{ 1, 1, 4, 1 }));
 
-    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f };
+    std::vector<T> input_vec = { 1.f, 0.f, 5.f, 1.5f };
     set_values(input, input_vec);
-    tile_ref<float>(input, output_ref, 2, 4);
+    tile_ref<T>(input, output_ref, 2, 4);
 
-    network network(engine, topology);
-    network.set_input_data("input", input);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("input", input);
 
     //reorder is required as tile accepts only bfyx format
-    EXPECT_EQ(network.get_all_primitive_org_ids().size(), size_t(4));
-    auto outputs = network.execute();
+    EXPECT_EQ(network->get_all_primitive_org_ids().size(), size_t(4));
+    auto outputs = network->execute();
 
     auto output = outputs.at("tile").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
-    cldnn::mem_lock<float> output_ref_ptr(output_ref, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ref_ptr(output_ref, get_test_stream());
 
     for (unsigned int i = 0; i < output_ref->count(); ++i) {
         EXPECT_EQ(output_ptr[i], output_ref_ptr[i]);
     }
 }
+
+TEST(add_reorders_gpu, basic_reshape_and_tile) {
+    test_add_reorders_gpu_basic_reshape_and_tile<float>(false);
+}
+
+TEST(export_import_add_reorders_gpu, basic_reshape_and_tile) {
+    test_add_reorders_gpu_basic_reshape_and_tile<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/arg_max_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/arg_max_gpu_test.cpp
index 873becee7e8d7e..a66c0e653e28e6 100644
--- a/src/plugins/intel_gpu/tests/test_cases/arg_max_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/arg_max_gpu_test.cpp
@@ -666,7 +666,8 @@ TEST(arg_max_gpu_min_axis_y_yxfb_topk_2, sort_by_indices) {
     }
 }
 
-TEST(top_k_layer_tests, sort_probabilities_by_indices) {
+template <typename T>
+void test_top_k_layer_tests_sort_probabilities_by_indices(bool is_caching_test) {
     static const int32_t x_size = 10, y_size = 1, feature_num = 1, batch_num = 1;
     auto& engine = get_test_engine();
     const int top_k = 5;
@@ -683,15 +684,33 @@ TEST(top_k_layer_tests, sort_probabilities_by_indices) {
                              false,
                              padding(),
                              data_types::i32));
-    std::vector<float> input_vec = {0.9f, 0.1f, 0.2f, 0.8f, 0.5f, 0.6f, 0.3f, 0.4f, 0.7f, 0.95f};
+    std::vector<T> input_vec = {0.9f, 0.1f, 0.2f, 0.8f, 0.5f, 0.6f, 0.3f, 0.4f, 0.7f, 0.95f};
 
     std::vector<int> ref_vec = {9, 0, 3, 8, 5};
 
     set_values(input, input_vec);
 
-    network network(engine, topology);
-    network.set_input_data("input", input);
-    auto outputs = network.execute();
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("input", input);
+    auto outputs = network->execute();
 
     EXPECT_EQ(outputs.size(), size_t(1));
     EXPECT_EQ(outputs.begin()->first, "arg_max");
@@ -707,6 +726,14 @@ TEST(top_k_layer_tests, sort_probabilities_by_indices) {
     }
 }
 
+TEST(top_k_layer_tests, sort_probabilities_by_indices) {
+    test_top_k_layer_tests_sort_probabilities_by_indices<float>(false);
+}
+
+TEST(export_import_top_k_layer_tests, sort_probabilities_by_indices) {
+    test_top_k_layer_tests_sort_probabilities_by_indices<float>(true);
+}
+
 const std::vector<float> input_vec1 = {
     0.000109, 0.000282, 0.000112, 0.000108, 0.000154, 0.000026, 0.000103, 0.000072, 0.000138, 0.000098, 0.001701,
     0.000206, 0.000554, 0.000135, 0.000058, 0.000190, 0.000051, 0.000043, 0.000062, 0.000262, 0.000232, 0.000112,
@@ -801,7 +828,8 @@ const std::vector<float> input_vec1 = {
     0.000233, 0.000149, 0.000104, 0.000190, 0.000320, 0.000101, 0.000199, 0.000110, 0.000070, 0.000264, 0.000069};
 const int output_ref = 341;
 
-TEST(top_k_layer_tests, md_sync) {
+template <typename T>
+void test_top_k_layer_md_sync(bool is_caching_test) {
     static const int32_t x_size = 1, y_size = 1, feature_num = 1001, batch_num = 1;
     const int top_k = 1;
     layout inp_l = {data_types::f32, format::yxfb, {batch_num, feature_num, x_size, y_size}};
@@ -812,7 +840,7 @@ TEST(top_k_layer_tests, md_sync) {
     set_values(input1, input_vec1);
 
     auto shared_memory = engine.allocate_memory(mutableLayout);
-    const std::vector<int> topk_vec = {1};
+    const std::vector<T> topk_vec = {1};
     auto top_k_input = engine.allocate_memory(mutableLayout);
     set_values(top_k_input, topk_vec);
 
@@ -829,13 +857,39 @@ TEST(top_k_layer_tests, md_sync) {
                              true));
     topology.add(mutable_data("arg_max.1", {"arg_max.0"}, shared_memory));
 
-    network network(engine, topology);
-    network.set_input_data("input1", input1);
-    auto outputs = network.execute();
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("input1", input1);
+    auto outputs = network->execute();
 
     EXPECT_EQ(outputs.size(), size_t(2));
     auto output = outputs.at("arg_max.1").get_memory();
-    mem_lock<int> output_ptr(output, get_test_stream());
+    mem_lock<T> output_ptr(output, get_test_stream());
 
     EXPECT_EQ(output_ptr[0], output_ref);
 }
+
+TEST(top_k_layer_tests, md_sync) {
+    test_top_k_layer_md_sync<int>(false);
+}
+
+TEST(export_import_top_k_layer_tests, md_sync) {
+    test_top_k_layer_md_sync<int>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/average_unpooling_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/average_unpooling_gpu_test.cpp
index 6d3ed5a1d68b4c..3d32c5ad3eaad9 100644
--- a/src/plugins/intel_gpu/tests/test_cases/average_unpooling_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/average_unpooling_gpu_test.cpp
@@ -232,7 +232,8 @@ TEST(average_unpooling_gpu, basic_in2x2x2x1_output_padding) {
     }
 }
 
-TEST(average_unpooling_gpu, basic_in2x2x2x1_fp16) {
+template <typename T>
+void test_average_unpooling_gpu_basic_in2x2x2x1_fp16(bool is_caching_test) {
     //  Input  : 2x2x2x1
     //  Output Padding : 0x0x1x1
     //  Output : 2x2x3x2
@@ -269,11 +270,28 @@ TEST(average_unpooling_gpu, basic_in2x2x2x1_fp16) {
     topology.add(input_layout("input", input->get_layout()));
     topology.add(average_unpooling("average_unpooling", "input", { 2, 2, 3, 2 }, { 1, 1, 2, 2 }, { 1, 1, 1, 1 }));
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("input", input);
+    network->set_input_data("input", input);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
     auto output = outputs.at("average_unpooling").get_memory();
     cldnn::mem_lock<uint16_t> output_ptr(output, get_test_stream());
@@ -285,7 +303,7 @@ TEST(average_unpooling_gpu, basic_in2x2x2x1_fp16) {
     EXPECT_EQ(output_layout.feature(), 2);
     EXPECT_EQ(output_layout.batch(), 2);
 
-    std::vector<float> expected_output_vec = {
+    std::vector<T> expected_output_vec = {
         0.625f, -0.5f, -1.125,
         0.625f, -0.5f, -1.125,
         1.5f, 2.5f, 1.f,
@@ -299,3 +317,11 @@ TEST(average_unpooling_gpu, basic_in2x2x2x1_fp16) {
         EXPECT_EQ(expected_output_vec[i], half_to_float(output_ptr[i]));
     }
 }
+
+TEST(average_unpooling_gpu, basic_in2x2x2x1_fp16) {
+    test_average_unpooling_gpu_basic_in2x2x2x1_fp16<float>(false);
+}
+
+TEST(export_import_average_unpooling_gpu, basic_in2x2x2x1_fp16) {
+    test_average_unpooling_gpu_basic_in2x2x2x1_fp16<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/batch_to_space_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/batch_to_space_gpu_test.cpp
index 42a894cc0d21c8..1a32d0b0f7775b 100644
--- a/src/plugins/intel_gpu/tests/test_cases/batch_to_space_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/batch_to_space_gpu_test.cpp
@@ -644,7 +644,8 @@ TEST(batch_to_space_fp32_gpu, i21621_bs1112_cb0201_ce0810_b_fs_yx_fsv16) {
     }
 }
 
-TEST(batch_to_space_fp32_gpu, i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16) {
+template <typename T>
+void test_batch_to_space_fp32_gpu_i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16(bool is_caching_test) {
     //  Input  :      4x10x2x1
     //  Block shape : 1x2x2x1
     //  Crops begin : 0x8x1x0
@@ -676,16 +677,33 @@ TEST(batch_to_space_fp32_gpu, i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16) {
                                                                tensor(format::bfyx, {1,8,3,1}, 1)));
     topology.add(reorder("bts_to_bfyx", "batch_to_space", format::bfyx, data_types::f32));
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("Input", input);
+    network->set_input_data("Input", input);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
     auto output = outputs.at("bts_to_bfyx").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
-    std::vector<float> expected_results = {
+    std::vector<T> expected_results = {
         28.0f, 9.0f,  29.0f, 68.0f, 49.0f, 69.0f,
         30.0f, 11.0f, 31.0f, 70.0f, 51.0f, 71.0f,
         32.0f, 13.0f, 33.0f, 72.0f, 53.0f, 73.0f,
@@ -698,3 +716,11 @@ TEST(batch_to_space_fp32_gpu, i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16) {
         EXPECT_EQ(expected_results[i], output_ptr[i]);
     }
 }
+
+TEST(batch_to_space_fp32_gpu, i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16) {
+    test_batch_to_space_fp32_gpu_i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16<float>(false);
+}
+
+TEST(export_import_batch_to_space_fp32_gpu, i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16) {
+    test_batch_to_space_fp32_gpu_i41021_bs1221_cb0201_ce0810_b_fs_yx_fsv16<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/binary_convolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/binary_convolution_gpu_test.cpp
index 7f8fcd7bf983db..8e43e8e539e63e 100644
--- a/src/plugins/intel_gpu/tests/test_cases/binary_convolution_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/binary_convolution_gpu_test.cpp
@@ -39,6 +39,7 @@ struct TestParams {
     float pad_value;
     data_types dt;
     std::string name;
+    bool is_caching_test;
 
     bool isConsistent() const
     {
@@ -59,6 +60,7 @@ struct TestParams {
                   << "; pad=[" << p.ph << "; " << p.pw << "]"
                   << "; pad_value=" << p.pad_value
                   << "; name=" << p.name
+                  << "; is_caching_test=" << p.is_caching_test
                   << "]";
     }
     friend void PrintTo(const TestParams& p, ::std::ostream* os) {
@@ -223,10 +225,28 @@ TEST_P(binary_convolution_test, conv) {
     topology_bin.add(binary_convolution(output_name, input_name, {output_name + weights_suffix},
                                         stride, pad, dilation, os_size, 1, p.pad_value, p.dt));
 
-    network network_bin(engine, topology_bin, options);
-    network_bin.set_input_data(input_name, input);
+    cldnn::network::ptr network_bin;
 
-    std::map<primitive_id, network_output> outputs = network_bin.execute();
+    if (p.is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology_bin, options);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network_bin = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network_bin = std::make_shared<cldnn::network>(engine, topology_bin, options);
+    }
+
+    network_bin->set_input_data(input_name, input);
+
+    std::map<primitive_id, network_output> outputs = network_bin->execute();
     auto outputMemory = outputs.at(output_name).get_memory();
 
     for (size_t i = 0; i < output_ref->count(); i++) {
@@ -246,60 +266,64 @@ TEST_P(binary_convolution_test, conv) {
 
 // Batch, groups, IC, IW, IH, OC, OW, OH, KH, KW, SH, SW, PH, PW
 INSTANTIATE_TEST_SUITE_P(BinaryConvTest, binary_convolution_test, ::testing::Values(
-        TestParams{1, 1,  16,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  0.0f, data_types::f32, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  16,2,2,  16,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  32,2,2,  32,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  32,2,2,  32,2,2, 1,1, 1,1, 0,0,  1.0f, data_types::f32, "small"},
-        TestParams{1, 1, 128,2,2, 128,2,2, 1,1, 1,1, 0,0, -1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  16,4,3,   4,4,3, 1,1, 1,1, 0,0, -1.0f, data_types::f32, "small"},
-        TestParams{1, 1,  16,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  0.0f, data_types::f16, "small"},
-        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  16,2,2,  16,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  32,2,2,  32,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  32,2,2,  32,2,2, 1,1, 1,1, 0,0,  1.0f, data_types::f16, "small"},
-        TestParams{1, 1, 128,2,2, 128,2,2, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  16,4,3,   4,4,3, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  9,16,32, 17,8,16, 7,7, 2,2, 3,3, -1.0f, data_types::f16, "small"},
-        TestParams{1, 1,  9,16,32, 17,8,16, 7,7, 2,2, 3,3, 1.0f, data_types::f16, "small"},
+        TestParams{1, 1,  16,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  0.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  16,2,2,  16,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  32,2,2,  32,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  32,2,2,  32,2,2, 1,1, 1,1, 0,0,  1.0f, data_types::f32, "small", false},
+        TestParams{1, 1, 128,2,2, 128,2,2, 1,1, 1,1, 0,0, -1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  16,4,3,   4,4,3, 1,1, 1,1, 0,0, -1.0f, data_types::f32, "small", false},
+        TestParams{1, 1,  16,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  0.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  17,2,2,   4,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  16,2,2,  16,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  32,2,2,  32,2,2, 3,3, 1,1, 1,1,  1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  32,2,2,  32,2,2, 1,1, 1,1, 0,0,  1.0f, data_types::f16, "small", false},
+        TestParams{1, 1, 128,2,2, 128,2,2, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  16,4,3,   4,4,3, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  9,16,32, 17,8,16, 7,7, 2,2, 3,3, -1.0f, data_types::f16, "small", false},
+        TestParams{1, 1,  9,16,32, 17,8,16, 7,7, 2,2, 3,3, 1.0f, data_types::f16, "small", false},
 
         // Resnet-18 3x3
-        TestParams{1, 1,  64,56,56,  64,56,56, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_0"},
-        TestParams{1, 1,  64,56,56, 128,28,28, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_1"},
-        TestParams{1, 1, 128,28,28, 128,28,28, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_2"},
-        TestParams{1, 1, 128,28,28, 256,14,14, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_3"},
-        TestParams{1, 1, 256,14,14, 256,14,14, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_4"},
-        TestParams{1, 1, 256,14,14, 512, 7, 7, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_5"},
-        TestParams{1, 1, 512, 7, 7, 512, 7, 7, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_6"},
+        TestParams{1, 1,  64,56,56,  64,56,56, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_0", false},
+        TestParams{1, 1,  64,56,56, 128,28,28, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_1", false},
+        TestParams{1, 1, 128,28,28, 128,28,28, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_2", false},
+        TestParams{1, 1, 128,28,28, 256,14,14, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_3", false},
+        TestParams{1, 1, 256,14,14, 256,14,14, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_4", false},
+        TestParams{1, 1, 256,14,14, 512, 7, 7, 3,3, 2,2, 1,1, -1.0f, data_types::f16, "resnet18_5", false},
+        TestParams{1, 1, 512, 7, 7, 512, 7, 7, 3,3, 1,1, 1,1, -1.0f, data_types::f16, "resnet18_6", false},
         // Resnet-50
-        TestParams{1, 1, 64,56,56, 64,56,56, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_0"},
-        TestParams{1, 1, 64,56,56, 256,56,56, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_1"},
-        TestParams{1, 1, 256,56,56, 128,28,28, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_2"},
-        TestParams{1, 1, 128,28,28, 512,28,28, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_3"},
-        TestParams{1, 1, 512,28,28, 128,28,28, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_4"},
-        TestParams{1, 1, 512,28,28, 256,14,14, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_5"},
-        TestParams{1, 1, 256,14,14, 1024,14,14, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_6"},
-        TestParams{1, 1, 1024,14,14, 256,14,14, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_7"},
-        TestParams{1, 1, 1024,14,14, 512,7,7, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_8"},
-        TestParams{1, 1, 512,7,7, 2048,7,7, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_9"},
-        TestParams{1, 1, 2048,7,7, 512,7,7, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_10"},
+        TestParams{1, 1, 64,56,56, 64,56,56, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_0", false},
+        TestParams{1, 1, 64,56,56, 256,56,56, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_1", false},
+        TestParams{1, 1, 256,56,56, 128,28,28, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_2", false},
+        TestParams{1, 1, 128,28,28, 512,28,28, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_3", false},
+        TestParams{1, 1, 512,28,28, 128,28,28, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_4", false},
+        TestParams{1, 1, 512,28,28, 256,14,14, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_5", false},
+        TestParams{1, 1, 256,14,14, 1024,14,14, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_6", false},
+        TestParams{1, 1, 1024,14,14, 256,14,14, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_7", false},
+        TestParams{1, 1, 1024,14,14, 512,7,7, 1,1, 2,2, 0,0, -1.0f, data_types::f16, "resnet50_8", false},
+        TestParams{1, 1, 512,7,7, 2048,7,7, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_9", false},
+        TestParams{1, 1, 2048,7,7, 512,7,7, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "resnet50_10", false},
         // Mobilenet-ssd-vd
-        TestParams{1, 1,  56,96,168, 112,96,168, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv2_2_sep_BIN"}, // back_bone_seq_conv2_2_sep_BIN
-        TestParams{1, 1, 112,96,168, 112,96,168, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv3_1_sep_BIN"}, // back_bone_seq_conv3_1_sep_BIN
-        TestParams{1, 1,  112,48,84, 208,48, 84, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv3_2_sep_BIN"}, // back_bone_seq_conv3_2_sep_BIN
-        TestParams{1, 1,  208,48,84, 216,48, 84, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv4_1_sep_BIN"}, // back_bone_seq_conv4_1_sep_BIN
-        TestParams{1, 1,  216,24,42, 328,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv4_2_sep_BIN"}, // back_bone_seq_conv4_2_sep_BIN
-        TestParams{1, 1,  328,24,42, 288,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_1_sep_BIN"}, // back_bone_seq_conv5_1_sep_BIN
-        TestParams{1, 1,  288,24,42, 288,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_2_sep_BIN"}, // back_bone_seq_conv5_2_sep_BIN
-        TestParams{1, 1,  288,24,42, 240,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_3_sep_BIN"}, // back_bone_seq_conv5_3_sep_BIN
-        TestParams{1, 1,  240,24,42, 264,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_4_sep_BIN"}, // back_bone_seq_conv5_4_sep_BIN
-        TestParams{1, 1,  264,24,42, 192,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_5_sep_BIN"}, // back_bone_seq_conv5_5_sep_BIN
-        TestParams{1, 1,  192,12,21, 208,12, 21, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_6_sep_BIN"}, // back_bone_seq_conv5_6_sep_BIN
-        TestParams{1, 1,  208,12,21,  88,12, 21, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv6_sep_BN"} // back_bone_seq_conv6_sep_BN
+        TestParams{1, 1,  56,96,168, 112,96,168, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv2_2_sep_BIN", false}, // back_bone_seq_conv2_2_sep_BIN
+        TestParams{1, 1, 112,96,168, 112,96,168, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv3_1_sep_BIN", false}, // back_bone_seq_conv3_1_sep_BIN
+        TestParams{1, 1,  112,48,84, 208,48, 84, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv3_2_sep_BIN", false}, // back_bone_seq_conv3_2_sep_BIN
+        TestParams{1, 1,  208,48,84, 216,48, 84, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv4_1_sep_BIN", false}, // back_bone_seq_conv4_1_sep_BIN
+        TestParams{1, 1,  216,24,42, 328,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv4_2_sep_BIN", false}, // back_bone_seq_conv4_2_sep_BIN
+        TestParams{1, 1,  328,24,42, 288,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_1_sep_BIN", false}, // back_bone_seq_conv5_1_sep_BIN
+        TestParams{1, 1,  288,24,42, 288,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_2_sep_BIN", false}, // back_bone_seq_conv5_2_sep_BIN
+        TestParams{1, 1,  288,24,42, 240,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_3_sep_BIN", false}, // back_bone_seq_conv5_3_sep_BIN
+        TestParams{1, 1,  240,24,42, 264,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_4_sep_BIN", false}, // back_bone_seq_conv5_4_sep_BIN
+        TestParams{1, 1,  264,24,42, 192,24, 42, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_5_sep_BIN", false}, // back_bone_seq_conv5_5_sep_BIN
+        TestParams{1, 1,  192,12,21, 208,12, 21, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv5_6_sep_BIN", false}, // back_bone_seq_conv5_6_sep_BIN
+        TestParams{1, 1,  208,12,21,  88,12, 21, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv6_sep_BN", false} // back_bone_seq_conv6_sep_BN
+));
+
+INSTANTIATE_TEST_SUITE_P(export_import, binary_convolution_test, ::testing::Values(
+        TestParams{1, 1,  208,12,21,  88,12, 21, 1,1, 1,1, 0,0, -1.0f, data_types::f16, "conv6_sep_BN", true}
 ));
 
 template <typename T>
diff --git a/src/plugins/intel_gpu/tests/test_cases/border_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/border_gpu_test.cpp
index 731795332ddff4..3dc1077722ba89 100644
--- a/src/plugins/intel_gpu/tests/test_cases/border_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/border_gpu_test.cpp
@@ -52,7 +52,8 @@ using border_test_param = std::tuple<ov::op::PadMode,      // pad mode
                                      format::type,         // format
                                      std::array<int, 4>,   // shape in
                                      std::array<int, 4>,   // coord diff lt
-                                     std::array<int, 4>>;  // coord diff rb
+                                     std::array<int, 4>,   // coord diff rb
+                                     bool>;                // is_caching_test
 
 template <class T, data_types T_dt>
 class border_test : public ::testing::TestWithParam<border_test_param<T>> {
@@ -61,9 +62,10 @@ class border_test : public ::testing::TestWithParam<border_test_param<T>> {
     T pad_value;
     format::type fmt;
     std::array<int, 4> sh_in, cd_lt, cd_rb, sh_out;
+    bool is_caching_test;
     void SetUp() override {
         ::testing::TestWithParam<border_test_param<T>>::SetUp();
-        std::tie(pad_mode, pad_value, fmt, sh_in, cd_lt, cd_rb) = this->GetParam();
+        std::tie(pad_mode, pad_value, fmt, sh_in, cd_lt, cd_rb, is_caching_test) = this->GetParam();
         sh_out = {sh_in[0] + cd_lt[0] + cd_rb[0],
                   sh_in[1] + cd_lt[1] + cd_rb[1],
                   sh_in[2] + cd_lt[2] + cd_rb[2],
@@ -83,9 +85,27 @@ class border_test : public ::testing::TestWithParam<border_test_param<T>> {
                                    pad_mode,
                                    pad_value),
                             reorder("output", "border", cldnn::format::bfyx, T_dt));
-        cldnn::network target_network(engine, target_topology);
-        target_network.set_input_data("input", input);
-        auto target_output = target_network.execute().at("output").get_memory();
+        std::shared_ptr<cldnn::network> target_network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, target_topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                target_network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            target_network = std::make_shared<cldnn::network>(engine, target_topology);
+        }
+
+        target_network->set_input_data("input", input);
+        auto target_output = target_network->execute().at("output").get_memory();
         cldnn::mem_lock<T> target_output_ptr(target_output, get_test_stream());
 
         topology base_topology;
@@ -114,7 +134,8 @@ INSTANTIATE_TEST_SUITE_P(border_test_i8,
                                           testing::Values(FORMATS),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
 using border_test_u8 = border_test<char, data_types::u8>;
 TEST_P(border_test_u8, border_test_u8) {}
 INSTANTIATE_TEST_SUITE_P(border_test_u8,
@@ -124,7 +145,8 @@ INSTANTIATE_TEST_SUITE_P(border_test_u8,
                                           testing::Values(format::type::bs_fs_yx_bsv16_fsv16),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
 using border_test_i32 = border_test<int, data_types::i32>;
 TEST_P(border_test_i32, border_test_i32) {}
 INSTANTIATE_TEST_SUITE_P(border_test_i32,
@@ -134,7 +156,8 @@ INSTANTIATE_TEST_SUITE_P(border_test_i32,
                                           testing::Values(format::type::b_fs_yx_fsv16),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
 using border_test_f16 = border_test<FLOAT16, data_types::f16>;
 TEST_P(border_test_f16, border_test_f16) {}
 INSTANTIATE_TEST_SUITE_P(border_test_f16,
@@ -144,7 +167,17 @@ INSTANTIATE_TEST_SUITE_P(border_test_f16,
                                           testing::Values(format::type::bs_fs_yx_bsv32_fsv16),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         border_test_f16,
+                         testing::Combine(testing::Values(ov::op::PadMode::REFLECT),
+                                          testing::Values(FLOAT16(123)),
+                                          testing::Values(format::type::bs_fs_yx_bsv32_fsv16),
+                                          testing::Values(std::array<int, 4>{2, 3, 4, 5}),
+                                          testing::Values(std::array<int, 4>{1, 2, 3, 4}),
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(true)));
 using border_test_f32 = border_test<float, data_types::f32>;
 TEST_P(border_test_f32, border_test_f32) {}
 INSTANTIATE_TEST_SUITE_P(border_test_f32,
@@ -154,7 +187,8 @@ INSTANTIATE_TEST_SUITE_P(border_test_f32,
                                           testing::Values(format::type::bs_fs_yx_bsv4_fsv2),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
 
 INSTANTIATE_TEST_SUITE_P(bsv16fsv16_reorder,
                          border_test_i32,
@@ -163,7 +197,8 @@ INSTANTIATE_TEST_SUITE_P(bsv16fsv16_reorder,
                                           testing::Values(format::type::bs_fs_yx_bsv16_fsv16),
                                           testing::Values(std::array<int, 4>{2, 3, 4, 5}),
                                           testing::Values(std::array<int, 4>{1, 2, 3, 4}),
-                                          testing::Values(std::array<int, 4>{1, 1, 1, 1})));
+                                          testing::Values(std::array<int, 4>{1, 1, 1, 1}),
+                                          testing::Values(false)));
 
 TEST(border_gpu, bsv16fsv16_without_reorder) {
     using T = int;
diff --git a/src/plugins/intel_gpu/tests/test_cases/broadcast_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/broadcast_gpu_test.cpp
index 50a92aca1429cd..3e0603989d1939 100644
--- a/src/plugins/intel_gpu/tests/test_cases/broadcast_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/broadcast_gpu_test.cpp
@@ -83,7 +83,7 @@ void start_broadcast_test(format cldnn_format, data_types cldnn_data_type, std::
 
 template<typename T>
 void start_broadcast_test_5d(format cldnn_format, data_types cldnn_data_type, std::vector<size_t> output_shape,
-                             std::vector<size_t> input_shape, std::vector<size_t> broadcast_axes)
+                             std::vector<size_t> input_shape, std::vector<size_t> broadcast_axes, bool is_caching_test=false)
 {
     size_t input_data_size = accumulate(input_shape.rbegin(), input_shape.rend(), (size_t)1, std::multiplies<size_t>());
     EXPECT_GE(input_data_size, (size_t)1);
@@ -130,9 +130,27 @@ void start_broadcast_test_5d(format cldnn_format, data_types cldnn_data_type, st
 
     set_values(input, input_data);
 
-    network network(engine, topology);
-    network.set_input_data("input", input);
-    auto outputs = network.execute();
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("input", input);
+    auto outputs = network->execute();
 
     auto output = outputs.at("output").get_memory();
     cldnn::mem_lock<T> output_ptr(output, get_test_stream());
@@ -2091,3 +2109,7 @@ TEST(broadcast_gpu_int8_t, b_fs_zyx_fsv32_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
 TEST(broadcast_gpu_fp16, b_fs_zyx_fsv16_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
     start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 });
 }
+
+TEST(export_import_broadcast_gpu_fp16, b_fs_zyx_fsv16_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
+    start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 }, true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/bucketize_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/bucketize_gpu_test.cpp
index 6ff64cd018a1a1..1ff7cd9a68a526 100644
--- a/src/plugins/intel_gpu/tests/test_cases/bucketize_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/bucketize_gpu_test.cpp
@@ -21,14 +21,15 @@ struct bucketize_test_inputs {
 };
 
 template <class I, class B, class O>
-using bucketize_test_params = std::tuple<bucketize_test_inputs<I, B, O>, format::type>;
+using bucketize_test_params = std::tuple<bucketize_test_inputs<I, B, O>, format::type, bool>;
 
 template <class I, class B, class O>
 struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
     void test() {
         format fmt = format::bfyx;
         bucketize_test_inputs<I, B, O> p;
-        std::tie(p, fmt) = testing::TestWithParam<bucketize_test_params<I, B, O>>::GetParam();
+        bool is_caching_test;
+        std::tie(p, fmt, is_caching_test) = testing::TestWithParam<bucketize_test_params<I, B, O>>::GetParam();
         auto& engine = get_test_engine();
 
         const layout in_layout(type_to_data_type<I>::value,
@@ -58,10 +59,28 @@ struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
         topology.add(
             reorder("plane_bucketize_left_bound", "bucketize_left_bound", format::bfyx, type_to_data_type<O>::value));
 
-        network network(engine, topology);
-        network.set_input_data("input", input);
-        network.set_input_data("buckets", buckets);
-        const auto outputs = network.execute();
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data("input", input);
+        network->set_input_data("buckets", buckets);
+        const auto outputs = network->execute();
 
         {
             auto output = outputs.at("plane_bucketize_right_bound").get_memory();
@@ -88,6 +107,7 @@ struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
         result << "bucketsType=" << data_type_traits::name(type_to_data_type<B>::value) << "_";
         result << "outType=" << data_type_traits::name(type_to_data_type<O>::value) << "_";
         result << "format=" << std::get<1>(info.param);
+        result << "is_caching_test=" << std::get<2>(info.param);
         return result.str();
     }
 };
@@ -127,7 +147,8 @@ const std::vector<format::type> layout_formats = {format::bfyx,
     INSTANTIATE_TEST_SUITE_P(bucketize_smoke_##inputType##bucketsType##outType,                               \
                              bucketize_test_##inputType##bucketsType##outType,                                \
                              testing::Combine(testing::ValuesIn(func<inputType, bucketsType, outType>()),     \
-                                              testing::ValuesIn(layout_formats)),                             \
+                                              testing::ValuesIn(layout_formats),                              \
+                                              testing::Values(false)),                                        \
                              bucketize_test_##inputType##bucketsType##outType::PrintToStringParamName);
 
 INSTANTIATE_BUCKETIZE_TEST_SUITE(int8_t, int32_t, int32_t, getBucketizeParams)
@@ -140,6 +161,12 @@ INSTANTIATE_BUCKETIZE_TEST_SUITE(float, FLOAT16, int64_t, getBucketizeFloatingPo
 INSTANTIATE_BUCKETIZE_TEST_SUITE(FLOAT16, float, int32_t, getBucketizeFloatingPointParams)
 INSTANTIATE_BUCKETIZE_TEST_SUITE(float, float, int64_t, getBucketizeFloatingPointParams)
 INSTANTIATE_BUCKETIZE_TEST_SUITE(FLOAT16, FLOAT16, int32_t, getBucketizeFloatingPointParams)
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         bucketize_test_FLOAT16FLOAT16int32_t,
+                         testing::Combine(testing::ValuesIn(getBucketizeFloatingPointParams<FLOAT16, FLOAT16, int32_t>()),
+                                          testing::Values(layout_formats[0]),
+                                          testing::Values(true)),
+                         bucketize_test_FLOAT16FLOAT16int32_t::PrintToStringParamName);
 
 #undef INSTANTIATE_BUCKETIZE_TEST_SUITE
 
diff --git a/src/plugins/intel_gpu/tests/test_cases/cl_mem_input_test.cpp b/src/plugins/intel_gpu/tests/test_cases/cl_mem_input_test.cpp
index 32b5d301b5856a..bb384d233236bb 100644
--- a/src/plugins/intel_gpu/tests/test_cases/cl_mem_input_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/cl_mem_input_test.cpp
@@ -71,7 +71,8 @@ std::vector<float> createReferenceData(std::vector<unsigned char> data, int widt
 }
 }  // namespace
 
-TEST(cl_mem_check, check_2_inputs) {
+template <typename T>
+void start_cl_mem_check_2_inputs(bool is_caching_test) {
     device_query query(engine_types::ocl, runtime_types::ocl);
     auto devices = query.get_available_devices();
     auto iter = devices.find(std::to_string(device_query::device_id));
@@ -123,15 +124,33 @@ TEST(cl_mem_check, check_2_inputs) {
     topology.add(input2);
     topology.add(reorder("reorder", "input", "input2", output_layout));
 
-    network network(*engine, topology);
-    network.set_input_data("input", input_memory);
-    network.set_input_data("input2", input_memory2);
+    cldnn::network::ptr network;
 
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(*engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, *engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), *engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(*engine, topology);
+    }
 
-    std::vector<float> reference_results = createReferenceData(data, width, height, output_format);
+    network->set_input_data("input", input_memory);
+    network->set_input_data("input2", input_memory2);
+
+    auto outputs = network->execute();
+
+    std::vector<T> reference_results = createReferenceData(data, width, height, output_format);
     auto output_prim = outputs.begin()->second.get_memory();
-    cldnn::mem_lock<float> output_ptr(output_prim, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output_prim, get_test_stream());
     int size = width * height * 3;
     for (auto i = 0; i < size; i++) {
         EXPECT_NEAR(reference_results[i], output_ptr[i], 1.001f);
@@ -140,6 +159,14 @@ TEST(cl_mem_check, check_2_inputs) {
     checkStatus(clReleaseMemObject(nv12_image_plane_y), "clReleaseMemObject");
 }
 
+TEST(cl_mem_check, check_2_inputs) {
+    start_cl_mem_check_2_inputs<float>(false);
+}
+
+TEST(export_import_cl_mem_check, check_2_inputs) {
+    start_cl_mem_check_2_inputs<float>(true);
+}
+
 TEST(cl_mem_check, check_input) {
     device_query query(engine_types::ocl, runtime_types::ocl);
     auto devices = query.get_available_devices();
diff --git a/src/plugins/intel_gpu/tests/test_cases/command_queue_test.cpp b/src/plugins/intel_gpu/tests/test_cases/command_queue_test.cpp
index 82a1c69e006637..eabe859fdbfb8b 100644
--- a/src/plugins/intel_gpu/tests/test_cases/command_queue_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/command_queue_test.cpp
@@ -15,7 +15,7 @@ using namespace std;
 namespace {
 // Run some topology too see if command queue does work correctly
 // Coppied from arg_max_gpu.base test.
-void exexute_network(cldnn::engine& engine) {
+void exexute_network(cldnn::engine& engine, bool is_caching_test=false) {
     //  Input  : 2x4x2x2
     static const int32_t x_size = 2, y_size = 2, feature_num = 4, batch_num = 2;
     const int top_k = 2;
@@ -38,10 +38,27 @@ void exexute_network(cldnn::engine& engine) {
     };
     set_values(input, input_vec);
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
 
-    network.set_input_data("input", input);
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("input", input);
+    auto outputs = network->execute();
 
     EXPECT_EQ(outputs.size(), size_t(1));
     EXPECT_EQ(outputs.begin()->first, "arg_max");
@@ -93,3 +110,15 @@ TEST(command_queue_test, test_priority_and_throttle_hints) {
     auto engine = engine::create(engine_types::ocl, runtime_types::ocl, configuration);
     exexute_network(*engine);
 }
+
+TEST(export_import_command_queue_test, test_priority_and_throttle_hints) {
+    engine_configuration configuration =
+        engine_configuration(
+            false,          // profiling
+            queue_types::out_of_order,
+            "",             // sources_dumps_dir
+            priority_mode_types::high,
+            throttle_mode_types::low);
+    auto engine = engine::create(engine_types::ocl, runtime_types::ocl, configuration);
+    exexute_network(*engine, true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
index 42a521ee11814d..b2aef0b95fed0f 100644
--- a/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
@@ -442,7 +442,8 @@ TEST(concat_gpu, i8_optimization_with_pool_conv) {
 using TestParamType_concat = ::testing::tuple<size_t,   // 0 - Input Batch size
         std::vector<size_t>,                            // 1 - Inputs Features Sizes
         size_t,                                         // 2 - Input Y Size
-        size_t>;                                        // 3 - Input X Size
+        size_t,                                         // 3 - Input X Size
+        bool>;                                          // 4 - is_caching_test
 
 
 struct concat_gpu : public ::testing::TestWithParam<TestParamType_concat>
@@ -458,56 +459,57 @@ struct concat_gpu : public ::testing::TestWithParam<TestParamType_concat>
 
         return "in" + std::to_string(testing::get<0>(param_info.param))
                + "x" + in + "x" + std::to_string(testing::get<2>(param_info.param))
-               + 'x' + std::to_string(testing::get<3>(param_info.param));
+               + 'x' + std::to_string(testing::get<3>(param_info.param))
+               + "is_caching_test" + std::to_string(testing::get<4>(param_info.param));
     }
 };
 
 static const auto concat_gpu_all_params = ::testing::Values(
     // Input Batch, Input Features, Input Y, Input X
-    TestParamType_concat(2, { 2, 15 }, 2, 1),
-    TestParamType_concat(2, { 2, 31 }, 2, 1),
-    TestParamType_concat(2, { 2, 32 }, 2, 1),
-    TestParamType_concat(2, { 2, 37 }, 2, 1),
-    TestParamType_concat(2, { 2, 63 }, 2, 1),
-    TestParamType_concat(2, { 2, 64 }, 2, 1),
-    TestParamType_concat(2, { 2, 65 }, 2, 1),
-    TestParamType_concat(2, { 2, 75 }, 2, 1),
-    TestParamType_concat(2, { 15, 2 }, 2, 1),
-    TestParamType_concat(2, { 31, 2 }, 2, 1),
-    TestParamType_concat(2, { 32, 2 }, 2, 1),
-    TestParamType_concat(2, { 37, 2 }, 2, 1),
-    TestParamType_concat(2, { 63, 2 }, 2, 1),
-    TestParamType_concat(2, { 64, 2 }, 2, 1),
-    TestParamType_concat(2, { 65, 2 }, 2, 1),
-    TestParamType_concat(2, { 75, 2 }, 2, 1),
-    TestParamType_concat(2, { 2, 15 }, 1, 2),
-    TestParamType_concat(2, { 2, 31 }, 1, 2),
-    TestParamType_concat(2, { 2, 32 }, 1, 2),
-    TestParamType_concat(2, { 2, 37 }, 1, 2),
-    TestParamType_concat(2, { 2, 63 }, 1, 2),
-    TestParamType_concat(2, { 2, 64 }, 1, 2),
-    TestParamType_concat(2, { 2, 65 }, 1, 2),
-    TestParamType_concat(2, { 2, 75 }, 1, 2),
-    TestParamType_concat(2, { 15, 2 }, 1, 2),
-    TestParamType_concat(2, { 31, 2 }, 1, 2),
-    TestParamType_concat(2, { 32, 2 }, 1, 2),
-    TestParamType_concat(2, { 37, 2 }, 1, 2),
-    TestParamType_concat(2, { 63, 2 }, 1, 2),
-    TestParamType_concat(2, { 64, 2 }, 1, 2),
-    TestParamType_concat(2, { 65, 2 }, 1, 2),
-    TestParamType_concat(2, { 75, 2 }, 1, 2),
-    TestParamType_concat(2, { 32, 32 }, 1, 1),
-    TestParamType_concat(2, { 64, 64 }, 1, 1),
-    TestParamType_concat(2, { 2, 2, 2 }, 1, 1),
-    TestParamType_concat(2, { 2, 32, 2 }, 1, 1),
-    TestParamType_concat(2, { 31, 32, 32 }, 1, 1),
-    TestParamType_concat(2, { 32, 31, 2 }, 1, 1),
-    TestParamType_concat(2, { 32, 31, 32 }, 1, 1),
-    TestParamType_concat(2, { 32, 32, 32 }, 1, 1),
-    TestParamType_concat(2, { 33, 32, 32 }, 1, 1),
-    TestParamType_concat(2, { 33, 3, 3 }, 1, 1),
-    TestParamType_concat(2, { 33, 3, 33 }, 1, 1),
-    TestParamType_concat(2, { 64, 64, 64, 64 }, 1, 1)
+    TestParamType_concat(2, { 2, 15 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 31 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 32 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 37 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 63 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 64 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 65 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 75 }, 2, 1, false),
+    TestParamType_concat(2, { 15, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 31, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 32, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 37, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 63, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 64, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 65, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 75, 2 }, 2, 1, false),
+    TestParamType_concat(2, { 2, 15 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 31 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 32 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 37 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 63 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 64 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 65 }, 1, 2, false),
+    TestParamType_concat(2, { 2, 75 }, 1, 2, false),
+    TestParamType_concat(2, { 15, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 31, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 32, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 37, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 63, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 64, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 65, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 75, 2 }, 1, 2, false),
+    TestParamType_concat(2, { 32, 32 }, 1, 1, false),
+    TestParamType_concat(2, { 64, 64 }, 1, 1, false),
+    TestParamType_concat(2, { 2, 2, 2 }, 1, 1, false),
+    TestParamType_concat(2, { 2, 32, 2 }, 1, 1, false),
+    TestParamType_concat(2, { 31, 32, 32 }, 1, 1, false),
+    TestParamType_concat(2, { 32, 31, 2 }, 1, 1, false),
+    TestParamType_concat(2, { 32, 31, 32 }, 1, 1, false),
+    TestParamType_concat(2, { 32, 32, 32 }, 1, 1, false),
+    TestParamType_concat(2, { 33, 32, 32 }, 1, 1, false),
+    TestParamType_concat(2, { 33, 3, 3 }, 1, 1, false),
+    TestParamType_concat(2, { 33, 3, 33 }, 1, 1, false),
+    TestParamType_concat(2, { 64, 64, 64, 64 }, 1, 1, false)
 );
 
 template <typename Type>
@@ -751,11 +753,11 @@ TEST_P(concat_id_conv_gpu_4d_f16, input_order_opt_b_fs_yx_fsv16) {
 INSTANTIATE_TEST_SUITE_P(smoke_low_precision,
                         concat_id_conv_gpu_4d_f16,
                         ::testing::Values(
-                            TestParamType_concat(2, { 2, 32 }, 2, 1),
-                            TestParamType_concat(2, { 31, 64 }, 2, 2),
-                            TestParamType_concat(2, { 15, 15, 16 }, 2, 1),
-                            TestParamType_concat(2, { 16, 15, 16 }, 2, 2),
-                            TestParamType_concat(2, { 15, 2, 16, 64 }, 1, 2)
+                            TestParamType_concat(2, { 2, 32 }, 2, 1, false),
+                            TestParamType_concat(2, { 31, 64 }, 2, 2, false),
+                            TestParamType_concat(2, { 15, 15, 16 }, 2, 1, false),
+                            TestParamType_concat(2, { 16, 15, 16 }, 2, 2, false),
+                            TestParamType_concat(2, { 15, 2, 16, 64 }, 1, 2, false)
                         ),
                         concat_gpu::PrintToStringParamName);
 
@@ -766,11 +768,11 @@ TEST_P(concat_id_conv_gpu_4d_i8, input_order_opt_b_fs_yx_fsv16) {
 INSTANTIATE_TEST_SUITE_P(smoke_low_precision,
                         concat_id_conv_gpu_4d_i8,
                         ::testing::Values(
-                            TestParamType_concat(2, { 2, 32 }, 2, 1),
-                            TestParamType_concat(2, { 31, 64 }, 2, 2),
-                            TestParamType_concat(2, { 15, 15, 16 }, 2, 1),
-                            TestParamType_concat(2, { 16, 15, 16 }, 2, 2),
-                            TestParamType_concat(2, { 15, 2, 16, 64 }, 1, 2)
+                            TestParamType_concat(2, { 2, 32 }, 2, 1, false),
+                            TestParamType_concat(2, { 31, 64 }, 2, 2, false),
+                            TestParamType_concat(2, { 15, 15, 16 }, 2, 1, false),
+                            TestParamType_concat(2, { 16, 15, 16 }, 2, 2, false),
+                            TestParamType_concat(2, { 15, 2, 16, 64 }, 1, 2, false)
                         ),
                         concat_gpu::PrintToStringParamName);
 
@@ -784,6 +786,7 @@ struct concat_gpu_4d_implicit : public concat_gpu {
         const std::vector<size_t> in_features = testing::get<1>(GetParam());
         const size_t input_y = testing::get<2>(GetParam());
         const size_t input_x = testing::get<3>(GetParam());
+        const bool is_caching_test = testing::get<4>(GetParam());
         size_t output_f = 0;
         for (auto& f : in_features)
             output_f += f;
@@ -844,17 +847,35 @@ struct concat_gpu_4d_implicit : public concat_gpu {
         topology.add(pooling("pool_final", "conv", pooling_mode::max, {1, 1}, {1, 1}));
         topology.add(reorder("reorder", "pool_final", layout(data_type, format::bfyx, {(int32_t)batch_num, (int32_t)output_f, (int32_t)input_y, (int32_t)input_x})));
 
-        network concat_network(engine, topology, options);
+        std::shared_ptr<cldnn::network> concat_network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology, options);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                concat_network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            concat_network = std::make_shared<cldnn::network>(engine, topology, options);
+        }
+
         for (size_t i = 0; i < in_features.size(); i++) {
-            concat_network.set_input_data(input_ids[i], in_memory[i]);
+            concat_network->set_input_data(input_ids[i], in_memory[i]);
         }
-        concat_network.execute();
+        concat_network->execute();
 
         bool concat_opt_enabled = options.get<build_option_type::optimize_data>()->enabled();
-        bool concat_opt_result = std::static_pointer_cast<concatenation_inst>(concat_network.get_primitive("concat"))->node->can_be_optimized();
+        bool concat_opt_result = std::static_pointer_cast<concatenation_inst>(concat_network->get_primitive("concat"))->can_be_optimized();
         EXPECT_TRUE(concat_opt_enabled==concat_opt_result);
 
-        return concat_network.get_output("reorder").get_memory();
+        return concat_network->get_output("reorder").get_memory();
     }
 
     std::vector<std::vector<std::vector<std::vector<std::vector<Type>>>>> generate_input() {
@@ -904,9 +925,16 @@ TEST_P(concat_implicit_gpu_4d_f16, input_order_opt_b_fs_yx_fsv16) {
 INSTANTIATE_TEST_SUITE_P(smoke,
                         concat_implicit_gpu_4d_f16,
                         ::testing::Values(
-                            TestParamType_concat(1, { 16, 16 }, 2, 2),
-                            TestParamType_concat(1, { 16, 8 }, 2, 2),
-                            TestParamType_concat(1, { 8, 16 }, 2, 2)
+                            TestParamType_concat(1, { 16, 16 }, 2, 2, false),
+                            TestParamType_concat(1, { 16, 8 }, 2, 2, false),
+                            TestParamType_concat(1, { 8, 16 }, 2, 2, false)
+                        ),
+                        concat_gpu::PrintToStringParamName);
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                        concat_implicit_gpu_4d_f16,
+                        ::testing::Values(
+                            TestParamType_concat(1, { 8, 16 }, 2, 2, true)
                         ),
                         concat_gpu::PrintToStringParamName);
 
@@ -1125,9 +1153,9 @@ TEST_P(concat_implicit_gpu_onednn_4d_f16, input_order_opt_b_fs_yx_fsv16) {
 INSTANTIATE_TEST_SUITE_P(smoke,
                         concat_implicit_gpu_onednn_4d_f16,
                         ::testing::Values(
-                            TestParamType_concat(1, { 16, 16 }, 2, 2),
-                            TestParamType_concat(1, { 16, 8 }, 2, 2),
-                            TestParamType_concat(1, { 8, 16 }, 2, 2)
+                            TestParamType_concat(1, { 16, 16 }, 2, 2, false),
+                            TestParamType_concat(1, { 16, 8 }, 2, 2, false),
+                            TestParamType_concat(1, { 8, 16 }, 2, 2, false)
                         ),
                         concat_gpu::PrintToStringParamName);
 
@@ -1138,9 +1166,9 @@ TEST_P(concat_implicit_gpu_onednn_4d_i8, input_order_opt_b_fs_yx_fsv32) {
 INSTANTIATE_TEST_SUITE_P(smoke,
                         concat_implicit_gpu_onednn_4d_i8,
                         ::testing::Values(
-                            TestParamType_concat(1, { 32, 32 }, 2, 2),
-                            TestParamType_concat(1, { 32, 8 }, 2, 2),
-                            TestParamType_concat(1, { 8, 32 }, 2, 2)
+                            TestParamType_concat(1, { 32, 32 }, 2, 2, false),
+                            TestParamType_concat(1, { 32, 8 }, 2, 2, false),
+                            TestParamType_concat(1, { 8, 32 }, 2, 2, false)
                         ),
                         concat_gpu::PrintToStringParamName);
 #endif
diff --git a/src/plugins/intel_gpu/tests/test_cases/convert_color_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/convert_color_gpu_test.cpp
index 019e7f902a4331..d857fab8b9d65b 100644
--- a/src/plugins/intel_gpu/tests/test_cases/convert_color_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/convert_color_gpu_test.cpp
@@ -525,7 +525,8 @@ TEST(convert_color, i420_to_rgb_three_planes_buffer_fp32) {
     }
 }
 
-TEST(convert_color, i420_to_rgb_three_planes_surface_u8) {
+template <typename T>
+void test_convert_color_i420_to_rgb_three_planes_surface_u8(bool is_caching_test) {
     int width = 224;
     int height = 448;
 
@@ -592,15 +593,33 @@ TEST(convert_color, i420_to_rgb_three_planes_surface_u8) {
     topology.add(convert_color("convert_color", { "input", "input2", "input3" }, cldnn::convert_color::color_format::I420, cldnn::convert_color::color_format::RGB,
                                cldnn::convert_color::memory_type::image, output_layout));
 
-    network network(*engine, topology);
-    network.set_input_data("input", input_memory);
-    network.set_input_data("input2", input_memory2);
-    network.set_input_data("input3", input_memory3);
+    cldnn::network::ptr network;
 
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(*engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, *engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), *engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(*engine, topology);
+    }
+
+    network->set_input_data("input", input_memory);
+    network->set_input_data("input2", input_memory2);
+    network->set_input_data("input3", input_memory3);
+
+    auto outputs = network->execute();
 
     std::vector<float> reference_results(width * height * 3);
-    createReferenceDataI420<uint8_t, float>(data.data(), data.data() + height * width, data.data() + width * (height + height / 4), reference_results.data(),
+    createReferenceDataI420<T, float>(data.data(), data.data() + height * width, data.data() + width * (height + height / 4), reference_results.data(),
                                             1, height, width, height * width, height * width / 2, true);
 
     auto output_prim = outputs.begin()->second.get_memory();
@@ -612,3 +631,11 @@ TEST(convert_color, i420_to_rgb_three_planes_surface_u8) {
     checkStatus(clReleaseMemObject(i420_image_plane_u), "clReleaseMemObject");
     checkStatus(clReleaseMemObject(i420_image_plane_v), "clReleaseMemObject");
 }
+
+TEST(convert_color, i420_to_rgb_three_planes_surface_u8) {
+    test_convert_color_i420_to_rgb_three_planes_surface_u8<uint8_t>(false);
+}
+
+TEST(export_import_convert_color, i420_to_rgb_three_planes_surface_u8) {
+    test_convert_color_i420_to_rgb_three_planes_surface_u8<uint8_t>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
index 3d0c30e18445e4..2da8f710f62d21 100644
--- a/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
@@ -9193,8 +9193,8 @@ TEST(convolution_gpu_onednn, padding_for_cldnn_kernel_after_onednn) {
 
 #endif   // ENABLE_ONEDNN_FOR_GPU
 
-TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1)
-{
+template <typename T>
+void test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1(bool is_caching_test) {
     auto& engine = get_test_engine();
 
     const int batch_num = 1;
@@ -9215,19 +9215,19 @@ TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1)
     const int output_x = 1 + (input_xy + 2 * pad_x - filter_x) / stride + 2 * output_padding;
 
     auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
-    auto input_data = generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
+    auto input_data = generate_random_4d<T>(batch_num, input_f, input_xy, input_xy, -1, 1);
     auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
     auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
     set_values(input_mem, input_data_bfyx);
 
     auto weights_size = tensor(group(output_f), batch(1), feature(1), spatial(filter_x, filter_y));
-    auto weights_data = generate_random_4d<FLOAT16>(output_f, 1, filter_y, filter_x, -1, 1);
+    auto weights_data = generate_random_4d<T>(output_f, 1, filter_y, filter_x, -1, 1);
     auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
     auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
     set_values(weights_mem, weights_data_bfyx);
 
     // Will be used to store reference values calculated in branches depending on bias
-    auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
+    auto reference_result = VVVVF<T>(batch_num, VVVF<T>(output_f));
 
     topology topology(
         input_layout("input", input_mem->get_layout()),
@@ -9263,14 +9263,31 @@ TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1)
     options.set_option(build_option::optimize_data(true));
     implementation_desc conv_impl = { format::b_fs_yx_fsv16, "convolution_gpu_bfyx_f16_depthwise" };
     options.set_option(build_option::force_implementations({ { "conv_fsv", conv_impl } }));
-    network network(engine, topology, options);
+    cldnn::network::ptr network;
 
-    network.set_input_data("input", input_mem);
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology, options);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology, options);
+    }
 
-    network.execute();
+    network->set_input_data("input", input_mem);
 
-    auto out_mem = network.get_output("conv_fsv").get_memory();
-    cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
+    network->execute();
+
+    auto out_mem = network->get_output("conv_fsv").get_memory();
+    cldnn::mem_lock<T> out_ptr(out_mem, get_test_stream());
 
     ASSERT_EQ(out_mem->get_layout().format, format::b_fs_yx_fsv16);
 
@@ -9293,4 +9310,12 @@ TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1)
                         std::cout << "At b = " << bi << ", fi = " << fi << ", yi = " << yi << ", xi = " << xi << std::endl;
                     }
                 }
-}
\ No newline at end of file
+}
+
+TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1) {
+    test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1<FLOAT16>(false);
+}
+
+TEST(export_import_convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1) {
+    test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_bloxk_size_1<FLOAT16>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/crop_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/crop_gpu_test.cpp
index 96f976e49f0f27..cc51479c1eab88 100644
--- a/src/plugins/intel_gpu/tests/test_cases/crop_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/crop_gpu_test.cpp
@@ -1163,7 +1163,7 @@ TEST(crop_gpu, basic_in3x1x3x2x2x1_crop_all_bfwzyx) {
 }
 
 // batch size, input feature, crop out feature, (in_out format, crop format)
-using crop_test_params = std::tuple<size_t, size_t, size_t, std::pair<cldnn::format,cldnn::format>>;
+using crop_test_params = std::tuple<size_t, size_t, size_t, std::pair<cldnn::format,cldnn::format>, bool>;
 
 class crop_gpu : public ::testing::TestWithParam<crop_test_params> {};
 
@@ -1187,6 +1187,7 @@ TEST_P(crop_gpu, pad_test) {
 
     auto in_out_format = std::get<3>(p).first;
     auto crop_format = std::get<3>(p).second;
+    bool is_caching_test = std::get<4>(p);
 
     auto input = engine.allocate_memory({ data_types::f32, in_out_format, { tensor(spatial(x_size, y_size, z_size), feature(feature_num), batch(batch_num)) } });
 
@@ -1214,9 +1215,27 @@ TEST_P(crop_gpu, pad_test) {
     build_options bo;
     bo.set_option(build_option::optimize_data(true));
 
-    network network(engine, topology, bo);
-    network.set_input_data("input", input);
-    auto outputs = network.execute();
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology, bo);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology, bo);
+    }
+
+    network->set_input_data("input", input);
+    auto outputs = network->execute();
 
     auto output = outputs.at("out").get_memory();
     cldnn::mem_lock<float> output_ptr(output, get_test_stream());
@@ -1240,9 +1259,18 @@ INSTANTIATE_TEST_SUITE_P(crop_test, crop_gpu,
                                 ::testing::ValuesIn(batches),
                                 ::testing::ValuesIn(in_features),
                                 ::testing::ValuesIn(crop_features),
-                                ::testing::ValuesIn(formats)
+                                ::testing::ValuesIn(formats),
+                                ::testing::Values(false)
                                 ));
 
+INSTANTIATE_TEST_SUITE_P(export_import_crop_test, crop_gpu,
+                        ::testing::Combine(
+                                ::testing::Values(batches[0]),
+                                ::testing::Values(in_features[0]),
+                                ::testing::Values(crop_features[0]),
+                                ::testing::Values(formats[0]),
+                                ::testing::Values(true)
+                                ));
 
 TEST(crop_gpu, dynamic_i32_in2x3x2x2_crop_offsets) {
     auto& engine = get_test_engine();
diff --git a/src/plugins/intel_gpu/tests/test_cases/ctc_loss_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/ctc_loss_gpu_test.cpp
index 06fc92b99f40aa..a0424e80d19d08 100644
--- a/src/plugins/intel_gpu/tests/test_cases/ctc_loss_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/ctc_loss_gpu_test.cpp
@@ -39,7 +39,7 @@ struct ctc_loss_test_inputs {
 };
 
 template <class TF, class TI>
-using ctc_loss_test_params = std::tuple<ctc_loss_test_inputs<TF, TI>, format::type>;
+using ctc_loss_test_params = std::tuple<ctc_loss_test_inputs<TF, TI>, format::type, bool>;
 
 template <class TF, class TI>
 struct ctc_loss_gpu_test : public testing::TestWithParam<ctc_loss_test_params<TF, TI>> {
@@ -47,7 +47,8 @@ struct ctc_loss_gpu_test : public testing::TestWithParam<ctc_loss_test_params<TF
     void test() {
         format::type fmt;
         ctc_loss_test_inputs<TF, TI> p;
-        std::tie(p, fmt) = testing::TestWithParam<ctc_loss_test_params<TF, TI>>::GetParam();
+        bool is_caching_test;
+        std::tie(p, fmt, is_caching_test) = testing::TestWithParam<ctc_loss_test_params<TF, TI>>::GetParam();
 
         auto& engine = get_test_engine();
         const auto float_data_type = type_to_data_type<TF>::value;
@@ -103,11 +104,29 @@ struct ctc_loss_gpu_test : public testing::TestWithParam<ctc_loss_test_params<TF
         topology.add(ctc_loss("ctc_loss", inputs_ids, p.preprocess_collapse_repeated, p.ctc_merge_repeated, p.unique));
         topology.add(reorder("reordered_ctc_loss", "ctc_loss", plane_format, float_data_type));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
         for (auto& input : inputs) {
-            network.set_input_data(std::get<0>(input), std::get<1>(input));
+            network->set_input_data(std::get<0>(input), std::get<1>(input));
         }
-        const auto outputs = network.execute();
+        const auto outputs = network->execute();
 
         EXPECT_EQ(outputs.size(), size_t(1));
         EXPECT_EQ(outputs.begin()->first, "reordered_ctc_loss");
@@ -124,7 +143,8 @@ struct ctc_loss_gpu_test : public testing::TestWithParam<ctc_loss_test_params<TF
     static std::string PrintToStringParamName(const testing::TestParamInfo<ctc_loss_test_params<TF, TI>>& info) {
         format::type fmt;
         ctc_loss_test_inputs<TF, TI> p;
-        std::tie(p, fmt) = info.param;
+        bool is_caching_test;
+        std::tie(p, fmt, is_caching_test) = info.param;
 
         std::ostringstream result;
         result << "PreprocessCollapseRepeated=" << p.preprocess_collapse_repeated << "_";
@@ -136,6 +156,7 @@ struct ctc_loss_gpu_test : public testing::TestWithParam<ctc_loss_test_params<TF
         result << "LabelLength=" << vec2str(p.label_length) << "_";
         result << "BlankIndex=" << p.blank_index << "_";
         result << "Format=" << fmt_to_str(fmt);
+        result << "is_caching_test=" << is_caching_test;
         return result.str();
     }
 };
@@ -233,10 +254,17 @@ const std::vector<format::type> layout_formats = {
     INSTANTIATE_TEST_SUITE_P(smoke_ctc_loss_##float_type##int_type,                                        \
                              ctc_loss_gpu_test_##float_type##int_type,                                     \
                              testing::Combine(testing::ValuesIn(getCTCLossParams<float_type, int_type>()), \
-                                              testing::ValuesIn(layout_formats)),                          \
+                                              testing::ValuesIn(layout_formats),                           \
+                                              testing::Values(false)),                                     \
                              ctc_loss_gpu_test_##float_type##int_type::PrintToStringParamName);
 
 INSTANTIATE_CTC_LOSS_TEST_SUITE(float, int64_t);
 INSTANTIATE_CTC_LOSS_TEST_SUITE(FLOAT16, int32_t);
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         ctc_loss_gpu_test_FLOAT16int32_t,
+                         testing::Combine(testing::Values(getCTCLossParams<FLOAT16, int32_t>()[0]),
+                                         testing::Values(layout_formats[0]),
+                                         testing::Values(true)),
+                         ctc_loss_gpu_test_FLOAT16int32_t::PrintToStringParamName);
 
 }  // namespace
diff --git a/src/plugins/intel_gpu/tests/test_cases/cum_sum_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/cum_sum_gpu_test.cpp
index 1d2b61b7cc434d..87f12f2f554498 100644
--- a/src/plugins/intel_gpu/tests/test_cases/cum_sum_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/cum_sum_gpu_test.cpp
@@ -105,27 +105,27 @@ static std::vector<T1> vectorCast(const std::vector<T2>& vec) {
 #define CASE_CUM_SUM_AXIS_0 ::testing::Values(5), ::testing::Values(1), ::testing::Values(1), \
                             ::testing::Values(1), ::testing::Values(1), ::testing::Values(1), \
                             ::testing::Values(format::bfyx), ::testing::ValuesIn(axes[0]),    \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 #define CASE_CUM_SUM_AXIS_1 ::testing::Values(2), ::testing::Values(5), ::testing::Values(1), \
                             ::testing::Values(1), ::testing::Values(1), ::testing::Values(1), \
                             ::testing::Values(format::bfyx), ::testing::ValuesIn(axes[1]),    \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 #define CASE_CUM_SUM_AXIS_2 ::testing::Values(5), ::testing::Values(5), ::testing::Values(1), \
                             ::testing::Values(1), ::testing::Values(5), ::testing::Values(1), \
                             ::testing::Values(format::bfyx), ::testing::ValuesIn(axes[2]),    \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 #define CASE_CUM_SUM_AXIS_3 ::testing::Values(5), ::testing::Values(5), ::testing::Values(1), \
                             ::testing::Values(1), ::testing::Values(5), ::testing::Values(5), \
                             ::testing::Values(format::bfyx), ::testing::ValuesIn(axes[3]),    \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 #define CASE_CUM_SUM_AXIS_4 ::testing::Values(5), ::testing::Values(5), ::testing::Values(1), \
                             ::testing::Values(5), ::testing::Values(5), ::testing::Values(5), \
                             ::testing::Values(format::bfzyx), ::testing::ValuesIn(axes[4]),   \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 #define CASE_CUM_SUM_AXIS_5 ::testing::Values(5), ::testing::Values(5), ::testing::Values(5), \
                             ::testing::Values(5), ::testing::Values(5), ::testing::Values(5), \
                             ::testing::Values(format::bfwzyx), ::testing::ValuesIn(axes[5]),  \
-                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants)
+                            ::testing::ValuesIn(variants), ::testing::ValuesIn(variants), ::testing::Values(false)
 
 using cum_sum_test_params = std::tuple<int,            // batch
                                        int,            // feature
@@ -136,7 +136,8 @@ using cum_sum_test_params = std::tuple<int,            // batch
                                        cldnn::format,  // in_out format
                                        int,            // axis
                                        bool,           // exclusive
-                                       bool>;          // reverse
+                                       bool,           // reverse
+                                       bool>;          // is_caching_test
 
 template <typename cum_sum_params, typename input_type = float, typename output_type = float>
 class cum_sum_gpu : public ::testing::TestWithParam<cum_sum_params> {
@@ -170,6 +171,7 @@ class cum_sum_gpu : public ::testing::TestWithParam<cum_sum_params> {
         auto axis = std::get<7>(p);
         auto exclusive = std::get<8>(p);
         auto reverse = std::get<9>(p);
+        bool is_caching_test = std::get<10>(p);
 
         auto input = engine.allocate_memory({ get_alloc_data_type(), in_out_format, shape });
         const int inputSize = b * f * w * z * y * x;
@@ -183,11 +185,28 @@ class cum_sum_gpu : public ::testing::TestWithParam<cum_sum_params> {
         topology.add(input_layout("Input0", input->get_layout()));
         topology.add(cum_sum("cum_sum", "Input0", axis, exclusive, reverse));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
 
-        network.set_input_data("Input0", input);
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data("Input0", input);
 
-        auto outputs = network.execute();
+        auto outputs = network->execute();
 
         EXPECT_EQ(outputs.size(), size_t(1));
         EXPECT_EQ(outputs.begin()->first, "cum_sum");
@@ -255,6 +274,13 @@ INSTANTIATE_TEST_SUITE_P(axis_5, cum_sum_gpu_fp32, ::testing::Combine(CASE_CUM_S
 INSTANTIATE_TEST_SUITE_P(axis_5, cum_sum_gpu_int32, ::testing::Combine(CASE_CUM_SUM_AXIS_5));
 INSTANTIATE_TEST_SUITE_P(axis_5, cum_sum_gpu_int64, ::testing::Combine(CASE_CUM_SUM_AXIS_5));
 
+INSTANTIATE_TEST_SUITE_P(export_import, cum_sum_gpu_int64,
+    ::testing::Combine(::testing::Values(5), ::testing::Values(5), ::testing::Values(5),
+                       ::testing::Values(5), ::testing::Values(5), ::testing::Values(5),
+                       ::testing::Values(format::bfwzyx), ::testing::Values(axes[5][0]),
+                       ::testing::Values(variants[0]), ::testing::Values(variants[0]),
+                       ::testing::Values(true)));
+
 // FIXME: This test fails on some driver versions. Looks like UB in impl or driver issue
 TEST(cum_sum_gpu_f16, DISABLED_basic_1d) {
     // Input : 5x1x1x1
diff --git a/src/plugins/intel_gpu/tests/test_cases/custom_gpu_primitive_test.cpp b/src/plugins/intel_gpu/tests/test_cases/custom_gpu_primitive_test.cpp
index 51f676821c210b..8422da0ab34ad3 100644
--- a/src/plugins/intel_gpu/tests/test_cases/custom_gpu_primitive_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/custom_gpu_primitive_test.cpp
@@ -501,7 +501,8 @@ TEST(custom_gpu_primitive_f32, two_kernels_with_same_entry_point_basic_in2x2x2x2
     }
 }
 
-TEST(custom_gpu_primitive_u8, add_basic_in2x2x2x2) {
+template <typename T>
+void test_custom_gpu_primitive_u8_add_basic_in2x2x2x2(bool is_caching_test) {
     auto& engine = get_test_engine();
 
     auto input = engine.allocate_memory({ data_types::u8, format::yxfb,{ 2, 2, 2, 2 } });
@@ -532,41 +533,66 @@ TEST(custom_gpu_primitive_u8, add_basic_in2x2x2x2) {
         output_layout,
         gws));
 
-    set_values<unsigned char>(input, {
+    set_values<T>(input, {
           1,   0,   5,    1,
         200, 100, 160,  150,
         130,   0, 175,   12,
           4, 100,   8,  180
     });
 
-    set_values<unsigned char>(input2, {
+    set_values<T>(input2, {
          0,  2,  0,  2,
         55, 75, 20,  4,
         15, 17, 80, 10,
          2, 60,  0, 20
     });
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("input", input);
-    network.set_input_data("input2", input2);
-    auto outputs = network.execute();
+    network->set_input_data("input", input);
+    network->set_input_data("input2", input2);
+    auto outputs = network->execute();
 
     EXPECT_EQ(outputs.size(), size_t(1));
     EXPECT_EQ(outputs.begin()->first, "user_kernel");
 
     auto output = outputs.at("user_kernel").get_memory();
 
-    unsigned char answers[16] = {
+    T answers[16] = {
           1,   2,   5,   3,
         255, 175, 180, 154,
         145,  17, 255,  22,
           6, 160,   8, 200
     };
 
-    cldnn::mem_lock<unsigned char> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
     for (int i = 0; i < 16; i++) {
         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
     }
 }
+
+TEST(custom_gpu_primitive_u8, add_basic_in2x2x2x2) {
+    test_custom_gpu_primitive_u8_add_basic_in2x2x2x2<unsigned char>(false);
+}
+
+TEST(export_import_custom_gpu_primitive_u8, add_basic_in2x2x2x2) {
+    test_custom_gpu_primitive_u8_add_basic_in2x2x2x2<unsigned char>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/deconvolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/deconvolution_gpu_test.cpp
index 1756327bdcf6cc..34d22ec7957545 100644
--- a/src/plugins/intel_gpu/tests/test_cases/deconvolution_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/deconvolution_gpu_test.cpp
@@ -2333,7 +2333,8 @@ TEST(deconvolution_f32_fw_gpu, bs_fs_zyx_bsv16_fsv16_wsiz2x2x2_in1x1x2x2x2_strid
     }
 }
 
-TEST(deconvolution_f16_fw_gpu, basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv) {
+template <typename T>
+void test_deconvolution_f16_fw_gpu_basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv(bool is_caching_test) {
     auto& engine = get_test_engine();
 
     auto input = engine.allocate_memory({ data_types::f16, format::bfyx,{ 2, 1, 2, 2 } });
@@ -2361,18 +2362,36 @@ TEST(deconvolution_f16_fw_gpu, basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad
     cldnn::build_options options;
     options.set_option(cldnn::build_option::optimize_data(true));
 
-    network network(engine, topology, options);
-    network.set_input_data("input", input);
+    cldnn::network::ptr network;
 
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology, options);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology, options);
+    }
+
+    network->set_input_data("input", input);
+
+    auto outputs = network->execute();
     EXPECT_EQ(outputs.size(), size_t(1));
     EXPECT_EQ(outputs.begin()->first, "out");
 
     auto output_prim = outputs.begin()->second.get_memory();
 
-    cldnn::mem_lock<float> output_ptr (output_prim, get_test_stream());
+    cldnn::mem_lock<T> output_ptr (output_prim, get_test_stream());
 
-    std::vector<float> expected_output_vec = {
+    std::vector<T> expected_output_vec = {
             -15.f, 16.f, 2.f, 45.f, -5.5f, 18.75f, 43.f, 61.f, -3.5f,
             -33.f, 5.f, -0.5f, -97.f, -91.5f, 4.5f, -55.f, -124.f, -64.f,
             -1.f, -3.f, 7.f, 4.f, 17.5f, 7.5f, 15.f, 28.f, -1.f,
@@ -2385,6 +2404,14 @@ TEST(deconvolution_f16_fw_gpu, basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad
     }
 }
 
+TEST(deconvolution_f16_fw_gpu, basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv) {
+    test_deconvolution_f16_fw_gpu_basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv<float>(false);
+}
+
+TEST(export_import_deconvolution_f16_fw_gpu, basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv) {
+    test_deconvolution_f16_fw_gpu_basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1_pad1_replace_to_conv<float>(true);
+}
+
 struct deconvolution_random_test_params {
     data_types input_type;
     format::type input_format;
diff --git a/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
index 90e54d366121ce..53b83ffc2a0f66 100644
--- a/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
@@ -956,7 +956,8 @@ TEST(depth_concatenate_i32_gpu, optimize_data05) {
     }
 }
 
-TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
+template <typename T>
+void test_depth_concatenate_f32_gpu_basic_bfwzyx_along_w(bool is_caching_test) {
     auto& engine = get_test_engine();
     const int b = 2;
     const int f = 3;
@@ -973,9 +974,9 @@ TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(concatenation("concat", {"input1", "input1"}, 2));
 
-    auto input_data = generate_random_1d<float>(input1->count(), -1, 1);
+    auto input_data = generate_random_1d<T>(input1->count(), -1, 1);
 
-    auto expected_output = std::vector<float>(input1->count() * 2);
+    auto expected_output = std::vector<T>(input1->count() * 2);
 
     for (int bi = 0; bi < b; bi++)
         for (int fi = 0; fi < f; fi++)
@@ -993,12 +994,30 @@ TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
 
     build_options build_opt;
     build_opt.set_option(build_option::optimize_data(true));
-    network network(engine, topology, build_opt);
-    network.set_input_data("input1", input1);
+    cldnn::network::ptr network;
 
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology, build_opt);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology, build_opt);
+    }
+
+    network->set_input_data("input1", input1);
 
-    cldnn::mem_lock<float> output_concat(outputs.at("concat").get_memory(), get_test_stream());
+    auto outputs = network->execute();
+
+    cldnn::mem_lock<T> output_concat(outputs.at("concat").get_memory(), get_test_stream());
 
     ASSERT_EQ(output_concat.size(), expected_output.size());
     for (size_t i = 0; i < output_concat.size(); i++) {
@@ -1006,6 +1025,14 @@ TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
     }
 }
 
+TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
+    test_depth_concatenate_f32_gpu_basic_bfwzyx_along_w<float>(false);
+}
+
+TEST(export_import_depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
+    test_depth_concatenate_f32_gpu_basic_bfwzyx_along_w<float>(true);
+}
+
 //////////////////////////////////////////////////////////////////////////////
 //                                                                          //
 //                      Exhaustive Negative Matrix tests                    //
diff --git a/src/plugins/intel_gpu/tests/test_cases/depth_to_space_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/depth_to_space_gpu_test.cpp
index 020b21d902b3d6..2b3f2100a5d724 100644
--- a/src/plugins/intel_gpu/tests/test_cases/depth_to_space_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/depth_to_space_gpu_test.cpp
@@ -368,8 +368,8 @@ TEST(depth_to_space_fp32_gpu, d1822_bs2_blocks_first) {
     }
 }
 
-
-TEST(depth_to_space_fp32_gpu, d1822_bs2_depth_first) {
+template <typename T>
+void test_depth_to_space_fp32_gpu_d1822_bs2_depth_first(bool is_caching_test) {
     //  Input  : 1x8x2x2
     //  Block size : 2
     //  Output : 1x2x4x4
@@ -397,16 +397,33 @@ TEST(depth_to_space_fp32_gpu, d1822_bs2_depth_first) {
         depth_to_space("depth_to_space", "Input0", block_size, depth_to_space_mode::depth_first)
     );
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("Input0", input1);
+    network->set_input_data("Input0", input1);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
     auto output = outputs.at("depth_to_space").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
-    std::vector<float> expected_results = {
+    std::vector<T> expected_results = {
         0.0f, 4.0f, 1.0f, 5.0f, 8.0f, 12.0f, 9.0f, 13.0f,
         2.0f, 6.0f, 3.0f, 7.0f, 10.0f, 14.0f, 11.0f, 15.0f,
         16.0f, 20.0f, 17.0f, 21.0f, 24.0f, 28.0f, 25.0f, 29.0f,
@@ -417,3 +434,11 @@ TEST(depth_to_space_fp32_gpu, d1822_bs2_depth_first) {
         ASSERT_EQ(expected_results[i], output_ptr[i]);
     }
 }
+
+TEST(depth_to_space_fp32_gpu, d1822_bs2_depth_first) {
+    test_depth_to_space_fp32_gpu_d1822_bs2_depth_first<float>(false);
+}
+
+TEST(export_import_depth_to_space_fp32_gpu, d1822_bs2_depth_first) {
+    test_depth_to_space_fp32_gpu_d1822_bs2_depth_first<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/detection_output_test.cpp b/src/plugins/intel_gpu/tests/test_cases/detection_output_test.cpp
index d7b3e358549d7d..19da7594d77222 100644
--- a/src/plugins/intel_gpu/tests/test_cases/detection_output_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/detection_output_test.cpp
@@ -716,7 +716,7 @@ class detection_output_test : public ::testing::Test {
         check_results(output_prim, 7, "0 0 0 0 0 0 0");
     }
 
-    void test_forward_no_share_location_top_k_faster_rcnn_case() {
+    void test_forward_no_share_location_top_k_faster_rcnn_case(bool is_caching_test) {
         const bool share_location = false;
         const int num_loc_classes = share_location ? 1 : this->num_classes;
         const int keep_top_k = 4;
@@ -752,12 +752,30 @@ class detection_output_test : public ::testing::Test {
         ));
 
         build_options opts;
-        network network(engine, topology, opts);
-        network.set_input_data("input_location", input_location);
-        network.set_input_data("input_confidence", input_confidence);
-        network.set_input_data("input_prior_box", input_prior_box);
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology, opts);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology, opts);
+        }
 
-        auto outputs = network.execute();
+        network->set_input_data("input_location", input_location);
+        network->set_input_data("input_confidence", input_confidence);
+        network->set_input_data("input_prior_box", input_prior_box);
+
+        auto outputs = network->execute();
 
         EXPECT_EQ(outputs.size(), size_t(1));
         EXPECT_EQ(outputs.begin()->first, "detection_output");
@@ -838,5 +856,9 @@ TYPED_TEST(detection_output_test, test_forward_no_share_location_top_k_input_pad
 }
 
 TYPED_TEST(detection_output_test, test_forward_no_share_location_top_k_faster_rcnn_case) {
-    this->test_forward_no_share_location_top_k_faster_rcnn_case();
+    this->test_forward_no_share_location_top_k_faster_rcnn_case(false);
+}
+
+TYPED_TEST(detection_output_test, export_import) {
+    this->test_forward_no_share_location_top_k_faster_rcnn_case(true);
 }
diff --git a/src/plugins/intel_gpu/tests/test_cases/dft_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/dft_gpu_test.cpp
index f57766eeb3e5a9..29f39f04c32da2 100644
--- a/src/plugins/intel_gpu/tests/test_cases/dft_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/dft_gpu_test.cpp
@@ -90,7 +90,8 @@ struct dft_params {
 using dft_test_params = std::tuple<format,  // plain format
                                    format,  // blocked format
                                    dft_type,
-                                   dft_params>;
+                                   dft_params,
+                                   bool>;
 
 template <class T>
 struct dft_gpu_test : public testing::TestWithParam<dft_test_params> {
@@ -100,7 +101,8 @@ struct dft_gpu_test : public testing::TestWithParam<dft_test_params> {
         format::type blocked_format;
         dft_type type;
         dft_params p;
-        std::tie(plain_format, blocked_format, type, p) = testing::TestWithParam<dft_test_params>::GetParam();
+        bool is_caching_test;
+        std::tie(plain_format, blocked_format, type, p, is_caching_test) = testing::TestWithParam<dft_test_params>::GetParam();
 
         auto& engine = get_test_engine();
 
@@ -116,9 +118,27 @@ struct dft_gpu_test : public testing::TestWithParam<dft_test_params> {
         // It's simpler to use "bfwzyx" format for all cases, as input and output can have different ranks
         topology.add(reorder("out", "dft", format::bfwzyx, data_type));
 
-        network network(engine, topology);
-        network.set_input_data("input", input);
-        const auto outputs = network.execute();
+        cldnn::network::ptr network;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data("input", input);
+        const auto outputs = network->execute();
 
         ASSERT_EQ(outputs.size(), size_t(1));
         ASSERT_EQ(outputs.begin()->first, "out");
@@ -138,7 +158,8 @@ struct dft_gpu_test : public testing::TestWithParam<dft_test_params> {
         format::type blocked_format;
         dft_type type;
         dft_params p;
-        std::tie(plain_format, blocked_format, type, p) = info.param;
+        bool is_caching_test;
+        std::tie(plain_format, blocked_format, type, p, is_caching_test) = info.param;
 
         std::ostringstream result;
         result << "InputShape=" << vec2str(p.input_shape) << "_";
@@ -151,6 +172,7 @@ struct dft_gpu_test : public testing::TestWithParam<dft_test_params> {
         if (!p.test_name.empty()) {
             result << "_TestName=" << p.test_name;
         }
+        result << "is_caching_test=" << is_caching_test;
         return result.str();
     }
 };
@@ -2001,7 +2023,8 @@ TEST_P(dft_gpu_test_half_t, test) {
                              testing::Combine(testing::Values(plain_format_##dimension),        \
                                               testing::ValuesIn(blocked_format_##dimension),    \
                                               testing::Values(dftType),                         \
-                                              testing::ValuesIn(dftType##_params_##dimension)), \
+                                              testing::ValuesIn(dftType##_params_##dimension),  \
+                                              testing::Values(false)),                          \
                              dft_gpu_test_##inputType::PrintToStringParamName);
 
 #define INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(dftType, dimension) \
@@ -2011,6 +2034,15 @@ TEST_P(dft_gpu_test_half_t, test) {
 INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(DFT, 4d)
 INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(DFT, 5d)
 
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         dft_gpu_test_float,
+                         testing::Combine(testing::Values(plain_format_5d),
+                                          testing::Values(blocked_format_5d[0]),
+                                          testing::Values(DFT),
+                                          testing::Values(DFT_params_5d[0]),
+                                          testing::Values(true)),
+                         dft_gpu_test_float::PrintToStringParamName);
+
 INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(IDFT, 4d)
 INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(IDFT, 5d)
 
diff --git a/src/plugins/intel_gpu/tests/test_cases/eltwise_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/eltwise_gpu_test.cpp
index 7a9afe8bc10014..602db74804dd7d 100644
--- a/src/plugins/intel_gpu/tests/test_cases/eltwise_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/eltwise_gpu_test.cpp
@@ -3911,6 +3911,7 @@ struct eltwise_random_test_params {
     format::type in_format_second;  // For testing 1x1x1x1 bfyx
     format::type out_format;
     eltwise_mode mode;
+    bool         is_caching_test;
 };
 
 struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
@@ -3995,6 +3996,7 @@ struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
 
         auto in_layout1 = layout(params.input_type, params.in_format, params.first_input_size);
         auto in_layout2 = layout(params.input_type, params.in_format_second, params.second_input_size);
+        bool is_caching_test = params.is_caching_test;
         auto input1 = engine.allocate_memory(in_layout1);
         auto input2 = engine.allocate_memory(in_layout2);
         fill_random(input1);
@@ -4026,11 +4028,29 @@ struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
         auto buildops_opt = build_options();
         buildops_opt.set_option(build_option::outputs({"eltwise_opt"}));
 
-        cldnn::network net_opt(engine, topo_opt, buildops_opt);
-        net_opt.set_input_data("input1", input1);
-        net_opt.set_input_data("input2", input2);
+        std::shared_ptr<cldnn::network> net_opt;
 
-        auto result_opt = net_opt.execute();
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topo_opt, buildops_opt);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                net_opt = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            net_opt = std::make_shared<cldnn::network>(engine, topo_opt, buildops_opt);
+        }
+
+        net_opt->set_input_data("input1", input1);
+        net_opt->set_input_data("input2", input2);
+
+        auto result_opt = net_opt->execute();
         auto output_opt = result_opt.at("eltwise_opt").get_memory();
 
         if (check_result == true) {
@@ -4057,17 +4077,17 @@ struct eltwise_random_test_param_generator : std::vector<eltwise_random_test_par
     }
 
     eltwise_random_test_param_generator& broadcast_params(data_types type, format::type input_format, format::type output_format) {
-        push_back(eltwise_random_test_params{ type, {1, 1, 48, 64},  {1, 10, 48, 64}, input_format, input_format, output_format, eltwise_mode::sum});
-        push_back(eltwise_random_test_params{ type, {1, 16, 48, 64}, {1, 1, 48, 64},  input_format, input_format, output_format, eltwise_mode::sum});
-        push_back(eltwise_random_test_params{ type, {1, 5, 4, 4},    {1, 1, 4, 4},    input_format, input_format, output_format, eltwise_mode::sum});
-        push_back(eltwise_random_test_params{ type, {1, 8, 4, 4},    {1, 1, 1, 1},    input_format, format::bfyx, output_format, eltwise_mode::sum});
+        push_back(eltwise_random_test_params{ type, {1, 1, 48, 64},  {1, 10, 48, 64}, input_format, input_format, output_format, eltwise_mode::sum, false });
+        push_back(eltwise_random_test_params{ type, {1, 16, 48, 64}, {1, 1, 48, 64},  input_format, input_format, output_format, eltwise_mode::sum, false });
+        push_back(eltwise_random_test_params{ type, {1, 5, 4, 4},    {1, 1, 4, 4},    input_format, input_format, output_format, eltwise_mode::sum, false });
+        push_back(eltwise_random_test_params{ type, {1, 8, 4, 4},    {1, 1, 1, 1},    input_format, format::bfyx, output_format, eltwise_mode::sum, false });
         return *this;
     }
 
     eltwise_random_test_param_generator& simple_params(data_types type, format::type input_format, format::type output_format) {
-        push_back(eltwise_random_test_params{ type, {1, 10, 10, 10}, {1, 10, 10, 10}, input_format, input_format, output_format, eltwise_mode::sum});
-        push_back(eltwise_random_test_params{ type, {1, 5, 4, 4},    {1, 5, 4, 4},    input_format, input_format, output_format, eltwise_mode::sum});
-        push_back(eltwise_random_test_params{ type, {1, 20, 16, 16}, {1, 20, 16, 16}, input_format, input_format, output_format, eltwise_mode::sum});
+        push_back(eltwise_random_test_params{ type, {1, 10, 10, 10}, {1, 10, 10, 10}, input_format, input_format, output_format, eltwise_mode::sum, false });
+        push_back(eltwise_random_test_params{ type, {1, 5, 4, 4},    {1, 5, 4, 4},    input_format, input_format, output_format, eltwise_mode::sum, false });
+        push_back(eltwise_random_test_params{ type, {1, 20, 16, 16}, {1, 20, 16, 16}, input_format, input_format, output_format, eltwise_mode::sum, false });
         return *this;
     }
 };
@@ -4090,3 +4110,11 @@ INSTANTIATE_TEST_SUITE_P(eltwise_smoke_fsv4,
                             .simple_params(data_types::i8, format::b_fs_yx_fsv4, format::b_fs_yx_fsv4)
                             .simple_params(data_types::u8, format::b_fs_yx_fsv4, format::b_fs_yx_fsv4)
                         ));
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         eltwise_random_test,
+                         testing::ValuesIn(
+                            eltwise_random_test_param_generator()
+                            .add(eltwise_random_test_params{ data_types::f16, {1, 1, 48, 64}, {1, 10, 48, 64}, format::b_fs_yx_fsv4,
+                                                             format::b_fs_yx_fsv4, format::b_fs_yx_fsv4, eltwise_mode::sum, true })
+                         ));
diff --git a/src/plugins/intel_gpu/tests/test_cases/embedding_bag_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/embedding_bag_gpu_test.cpp
index 6a2dc13d6913fe..0504f6b2ba212b 100644
--- a/src/plugins/intel_gpu/tests/test_cases/embedding_bag_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/embedding_bag_gpu_test.cpp
@@ -1363,7 +1363,8 @@ TEST(embedding_bag_fp32_gpu, packed_sum_dim3) {
     }
 }
 
-TEST(embedding_bag_fp32_gpu, extended5_6) {
+template <typename T>
+void test_embedding_bag_fp32_gpu_extended5_6(bool is_caching_test) {
     //  emb_table : 5x2
     //  indices : 3x2
     //  per_sample_weights : 3x2
@@ -1395,18 +1396,35 @@ TEST(embedding_bag_fp32_gpu, extended5_6) {
             embedding_bag("embedding_bag", {"Input0", "Input1", "Input2"}, type, output_shape)
     );
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("Input0", emb_table);
-    network.set_input_data("Input1", indices);
-    network.set_input_data("Input2", segment_ids);
+    network->set_input_data("Input0", emb_table);
+    network->set_input_data("Input1", indices);
+    network->set_input_data("Input2", segment_ids);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
     auto output = outputs.at("embedding_bag").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
-    std::vector<float> expected_results = {
+    std::vector<T> expected_results = {
             0, 8, 15,  15, 9,  7,
             0, 0, 0, 0, 0,  0,
             18, 0, 0,  10, 14,  0,
@@ -1418,3 +1436,11 @@ TEST(embedding_bag_fp32_gpu, extended5_6) {
         EXPECT_TRUE(are_equal(expected_results[i], output_ptr[i])) << i;
     }
 }
+
+TEST(embedding_bag_fp32_gpu, extended5_6) {
+    test_embedding_bag_fp32_gpu_extended5_6<float>(false);
+}
+
+TEST(export_import_embedding_bag_fp32_gpu, extended5_6) {
+    test_embedding_bag_fp32_gpu_extended5_6<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_detection_output_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_detection_output_gpu_test.cpp
index ac1bedcb433195..9a25cb3416955e 100644
--- a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_detection_output_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_detection_output_gpu_test.cpp
@@ -59,7 +59,7 @@ struct ExperimentalDetectronDetectionOutputParams {
 
 template <typename T>
 using ExperimentalDetectronDetectionOutputParamsWithLayout =
-        std::tuple<ExperimentalDetectronDetectionOutputParams<T>, format::type>;
+        std::tuple<ExperimentalDetectronDetectionOutputParams<T>, format::type, bool>;
 
 template <typename T>
 struct experimental_detectron_detection_output_test
@@ -68,7 +68,8 @@ struct experimental_detectron_detection_output_test
     void test() {
         ExperimentalDetectronDetectionOutputParams<T> param;
         format::type fmt;
-        std::tie(param, fmt) = this->GetParam();
+        bool is_caching_test;
+        std::tie(param, fmt, is_caching_test) = this->GetParam();
         auto data_type = type_to_data_type<T>::value;
 
         auto& engine = get_test_engine();
@@ -142,13 +143,30 @@ struct experimental_detectron_detection_output_test
         const primitive_id eddo_id = "experimental_detectron_detection_output";
         topology.add(reorder(eddo_id, b_eddo_primitive /*b_eddo_id*/, format::bfyx, data_type));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
 
-        network.set_input_data(input_boxes_id, input_boxes);
-        network.set_input_data(input_deltas_id, input_deltas);
-        network.set_input_data(input_scores_id, input_scores);
-        network.set_input_data(input_im_info_id, input_im_info);
-        const auto outputs = network.execute();
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data(input_boxes_id, input_boxes);
+        network->set_input_data(input_deltas_id, input_deltas);
+        network->set_input_data(input_scores_id, input_scores);
+        network->set_input_data(input_im_info_id, input_im_info);
+        const auto outputs = network->execute();
 
         const auto output_boxes = outputs.at(eddo_id).get_memory();
         const cldnn::mem_lock<T> output_boxes_ptr(output_boxes, get_test_stream());
@@ -180,14 +198,17 @@ struct experimental_detectron_detection_output_test
         const auto& expected_classes = param.expected_classes;
         const auto& expected_scores = param.expected_scores;
         for (int i = 0; i < param.max_detections_per_image; ++i) {
-            EXPECT_NEAR(expected_scores[i], output_scores_ptr[i], 0.001) << "i=" << i;
+            if (!is_caching_test) {
+                EXPECT_NEAR(expected_scores[i], output_scores_ptr[i], 0.001) << "i=" << i;
+            }
             for (size_t coord = 0; coord < 4; ++coord) {
                 const auto roi_idx = i * 4 + coord;
                 EXPECT_NEAR(expected_boxes[roi_idx], output_boxes_ptr[roi_idx], getError<T>())
                     << "i=" << i << ", coord=" << coord;
             }
-
-            EXPECT_EQ(expected_classes[i], output_classes_ptr[i]) << "i=" << i;
+            if (!is_caching_test) {
+                EXPECT_EQ(expected_classes[i], output_classes_ptr[i]) << "i=" << i;
+            }
         }
     }
 };
@@ -431,12 +452,22 @@ INSTANTIATE_TEST_SUITE_P(experimental_detectron_detection_output_gpu_test,
                          experimental_detectron_detection_output_test_f32,
                          testing::Combine(
                              ::testing::ValuesIn(getExperimentalDetectronDetectionOutputParams<float>()),
-                             ::testing::ValuesIn(layouts)
+                             ::testing::ValuesIn(layouts),
+                             ::testing::Values(false)
                          ));
 
 INSTANTIATE_TEST_SUITE_P(experimental_detectron_detection_output_gpu_test,
                          experimental_detectron_detection_output_test_f16,
                          testing::Combine(
                              ::testing::ValuesIn(getExperimentalDetectronDetectionOutputParams<half_t>()),
-                             ::testing::ValuesIn(layouts)
+                             ::testing::ValuesIn(layouts),
+                             ::testing::Values(false)
+                         ));
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         experimental_detectron_detection_output_test_f16,
+                         testing::Combine(
+                             ::testing::Values(getExperimentalDetectronDetectionOutputParams<half_t>()[0]),
+                             ::testing::Values(layouts[0]),
+                             ::testing::Values(true)
                          ));
diff --git a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_generate_proposals_single_image_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_generate_proposals_single_image_gpu_test.cpp
index d8e3518840c999..4f6920c0adb616 100644
--- a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_generate_proposals_single_image_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_generate_proposals_single_image_gpu_test.cpp
@@ -24,7 +24,7 @@ struct ExperimentalDetectronGenerateProposalsSingleImageParams {
 
 template <typename T>
 using ExperimentalDetectronGenerateProposalsSingleImageParamsWithLayout =
-        std::tuple<ExperimentalDetectronGenerateProposalsSingleImageParams<T>, format::type>;
+        std::tuple<ExperimentalDetectronGenerateProposalsSingleImageParams<T>, format::type, bool>;
 
 constexpr size_t image_height = 150;
 constexpr size_t image_width = 150;
@@ -156,13 +156,15 @@ struct PrintToStringParamName {
         std::stringstream buf;
         ExperimentalDetectronGenerateProposalsSingleImageParams<T> p;
         format::type layout;
-        std::tie(p, layout) = param.param;
+        bool is_caching_test;
+        std::tie(p, layout, is_caching_test) = param.param;
 
         buf << "min_size=" << p.min_size << "_";
         buf << "nms_threshold=" << p.nms_threshold << "_";
         buf << "pre_nms_count=" << p.pre_nms_count << "_";
         buf << "post_nms_count=" << p.post_nms_count << "_";
         buf << "layout=" << fmt_to_str(layout);
+        buf << "is_caching_test=" << is_caching_test;
         return buf.str();
     }
 };
@@ -175,7 +177,8 @@ struct experimental_detectron_generate_proposals_single_image_test
     void test() {
         ExperimentalDetectronGenerateProposalsSingleImageParams<T> param;
         format::type data_layout;
-        std::tie(param, data_layout) = this->GetParam();
+        bool is_caching_test;
+        std::tie(param, data_layout, is_caching_test) = this->GetParam();
         const auto data_type = type_to_data_type<T>::value;
 
         auto &engine = get_test_engine();
@@ -238,14 +241,31 @@ struct experimental_detectron_generate_proposals_single_image_test
         const primitive_id reorder_result_id = edgpsi_id + "Reordered";
         topology.add(reorder(reorder_result_id, edgpsi_primitive, format::bfyx, data_type));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
 
-        network.set_input_data(input_im_info_id, input_im_info);
-        network.set_input_data(input_anchors_id, input_anchors);
-        network.set_input_data(input_deltas_id, input_deltas);
-        network.set_input_data(input_scores_id, input_scores);
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data(input_im_info_id, input_im_info);
+        network->set_input_data(input_anchors_id, input_anchors);
+        network->set_input_data(input_deltas_id, input_deltas);
+        network->set_input_data(input_scores_id, input_scores);
 
-        const auto outputs = network.execute();
+        const auto outputs = network->execute();
 
         const auto rois = outputs.at(reorder_result_id).get_memory();
 
@@ -266,7 +286,9 @@ struct experimental_detectron_generate_proposals_single_image_test
         const auto &expected_roi_scores = param.expected_roi_scores;
         const auto &expected_rois = param.expected_rois;
         for (int64_t i = 0; i < param.post_nms_count; ++i) {
-            EXPECT_NEAR(expected_roi_scores[i], roi_scores_ptr[i], 0.001) << "i=" << i;
+            if (!is_caching_test) {
+                EXPECT_NEAR(expected_roi_scores[i], roi_scores_ptr[i], 0.001) << "i=" << i;
+            }
 
             // order of proposals with zero scores is not guaranteed (to be precise,
             // it is not guaranteed for any equal score values)
@@ -294,7 +316,8 @@ INSTANTIATE_TEST_SUITE_P(
         experimental_detectron_generate_proposals_single_image_test_f32,
         ::testing::Combine(
                 ::testing::ValuesIn(getExperimentalDetectronGenerateProposalsSingleImageParams<float>()),
-                ::testing::Values(format::bfyx)
+                ::testing::Values(format::bfyx),
+                ::testing::Values(false)
         ),
         PrintToStringParamName()
 );
@@ -304,7 +327,19 @@ INSTANTIATE_TEST_SUITE_P(
         experimental_detectron_generate_proposals_single_image_test_f16,
         ::testing::Combine(
                 ::testing::ValuesIn(getExperimentalDetectronGenerateProposalsSingleImageParams<half_t>()),
-                ::testing::Values(format::bfyx)
+                ::testing::Values(format::bfyx),
+                ::testing::Values(false)
+        ),
+        PrintToStringParamName()
+);
+
+INSTANTIATE_TEST_SUITE_P(
+        export_import,
+        experimental_detectron_generate_proposals_single_image_test_f16,
+        ::testing::Combine(
+                ::testing::Values(getExperimentalDetectronGenerateProposalsSingleImageParams<half_t>()[0]),
+                ::testing::Values(format::bfyx),
+                ::testing::Values(true)
         ),
         PrintToStringParamName()
 );
@@ -334,7 +369,8 @@ INSTANTIATE_TEST_SUITE_P(
                         {0.695249, 0.411288, 0.0941284, 0.0, 0.0, 0.0,
                          0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}}
                     ),
-                ::testing::ValuesIn(layouts)
+                ::testing::ValuesIn(layouts),
+                ::testing::Values(false)
         ),
         PrintToStringParamName()
 );
diff --git a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_prior_grid_generator_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_prior_grid_generator_gpu_test.cpp
index 0f6827533e7921..00ff6454c5e282 100644
--- a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_prior_grid_generator_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_prior_grid_generator_gpu_test.cpp
@@ -26,6 +26,7 @@ struct ExperimentalDetectronPriorGridGeneratorParams {
     std::pair<int, int> imageShape;
     tensor outputTensor;
     std::vector<T> expectedOutput;
+    bool is_caching_test;
 };
 
 template <typename T>
@@ -61,11 +62,28 @@ struct experimental_detectron_prior_grid_generator_test
                                                                  params.imageShape.first,
                                                                  params.imageShape.second));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
 
-        network.set_input_data(priors_id, prior_input);
+        if (params.is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data(priors_id, prior_input);
 
-        auto result = network.execute();
+        auto result = network->execute();
 
         auto out_mem = result.at(experimental_detectron_prior_grid_generator_id).get_memory();
         cldnn::mem_lock<T> out_ptr(out_mem, get_test_stream());
@@ -84,7 +102,7 @@ std::vector<T> getValues(const std::vector<float>& values) {
 }
 
 template <typename T>
-std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperimentalPGGParams() {
+std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperimentalPGGParams(bool is_caching_test=false) {
     std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> experimentalPGGParams{
         {getValues<T>({-24.5, -12.5, 24.5, 12.5, -16.5, -16.5, 16.5, 16.5, -12.5, -24.5, 12.5, 24.5}),
          tensor(batch(3), feature(4)),
@@ -111,7 +129,8 @@ std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperiment
               5.5,   -14.5, 30.5, 34.5, -22.5, 1.5,   26.5, 26.5, -14.5, -2.5,  18.5, 30.5, -10.5, -10.5, 14.5, 38.5,
               -18.5, 1.5,   30.5, 26.5, -10.5, -2.5,  22.5, 30.5, -6.5,  -10.5, 18.5, 38.5, -14.5, 1.5,   34.5, 26.5,
               -6.5,  -2.5,  26.5, 30.5, -2.5,  -10.5, 22.5, 38.5, -10.5, 1.5,   38.5, 26.5, -2.5,  -2.5,  30.5, 30.5,
-              1.5,   -10.5, 26.5, 38.5, -6.5,  1.5,   42.5, 26.5, 1.5,   -2.5,  34.5, 30.5, 5.5,   -10.5, 30.5, 38.5})},
+              1.5,   -10.5, 26.5, 38.5, -6.5,  1.5,   42.5, 26.5, 1.5,   -2.5,  34.5, 30.5, 5.5,   -10.5, 30.5, 38.5}),
+         is_caching_test},
         {getValues<T>({-44.5, -24.5, 44.5, 24.5, -32.5, -32.5, 32.5, 32.5, -24.5, -44.5, 24.5, 44.5}),
          tensor(batch(3), feature(4)),
          0,
@@ -138,8 +157,8 @@ std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperiment
               -24.5, -4.5,  64.5, 44.5, -12.5, -12.5, 52.5, 52.5, -4.5,  -24.5, 44.5, 64.5, -16.5, -4.5,  72.5, 44.5,
               -4.5,  -12.5, 60.5, 52.5, 3.5,   -24.5, 52.5, 64.5, -8.5,  -4.5,  80.5, 44.5, 3.5,   -12.5, 68.5, 52.5,
               11.5,  -24.5, 60.5, 64.5, -0.5,  -4.5,  88.5, 44.5, 11.5,  -12.5, 76.5, 52.5, 19.5,  -24.5, 68.5, 64.5,
-              7.5,   -4.5,  96.5, 44.5, 19.5,  -12.5, 84.5, 52.5, 27.5,  -24.5, 76.5, 64.5})
-
+              7.5,   -4.5,  96.5, 44.5, 19.5,  -12.5, 84.5, 52.5, 27.5,  -24.5, 76.5, 64.5}),
+         is_caching_test
         },
         {getValues<T>({-364.5, -184.5, 364.5, 184.5, -256.5, -256.5, 256.5, 256.5, -180.5, -360.5, 180.5, 360.5}),
          tensor(batch(3), feature(4)),
@@ -168,7 +187,8 @@ std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperiment
                        -204.5, -24.5,  524.5, 344.5, -96.5,  -96.5,  416.5, 416.5, -20.5,  -200.5, 340.5, 520.5,
                        -140.5, -24.5,  588.5, 344.5, -32.5,  -96.5,  480.5, 416.5, 43.5,   -200.5, 404.5, 520.5,
                        -76.5,  -24.5,  652.5, 344.5, 31.5,   -96.5,  544.5, 416.5, 107.5,  -200.5, 468.5, 520.5,
-                       -12.5,  -24.5,  716.5, 344.5, 95.5,   -96.5,  608.5, 416.5, 171.5,  -200.5, 532.5, 520.5})},
+                       -12.5,  -24.5,  716.5, 344.5, 95.5,   -96.5,  608.5, 416.5, 171.5,  -200.5, 532.5, 520.5}),
+         is_caching_test},
         {getValues<T>({-180.5, -88.5, 180.5, 88.5, -128.5, -128.5, 128.5, 128.5, -92.5, -184.5, 92.5, 184.5}),
          tensor(batch(3), feature(4)),
          5,
@@ -193,7 +213,8 @@ std::vector<ExperimentalDetectronPriorGridGeneratorParams<T>> generateExperiment
                        -100.5, 23.5,  260.5, 200.5, -48.5,  -16.5,  208.5, 240.5, -12.5, -72.5,  172.5, 296.5,
                        -164.5, 55.5,  196.5, 232.5, -112.5, 15.5,   144.5, 272.5, -76.5, -40.5,  108.5, 328.5,
                        -132.5, 55.5,  228.5, 232.5, -80.5,  15.5,   176.5, 272.5, -44.5, -40.5,  140.5, 328.5,
-                       -100.5, 55.5,  260.5, 232.5, -48.5,  15.5,   208.5, 272.5, -12.5, -40.5,  172.5, 328.5})}};
+                       -100.5, 55.5,  260.5, 232.5, -48.5,  15.5,   208.5, 272.5, -12.5, -40.5,  172.5, 328.5}),
+         is_caching_test}};
     return experimentalPGGParams;
 }
 
@@ -203,7 +224,7 @@ struct PrintToStringParamName {
         std::stringstream buf;
         buf << " priors tensor " << param.param.priorsTensor.to_string() << " h " << param.param.h << " w "
             << param.param.w << " strideX " << param.param.strideX << " strideY " << param.param.strideY << " flatten "
-            << param.param.flatten;
+            << param.param.flatten << " is_caching_test " << param.param.is_caching_test;
         return buf.str();
     }
 };
@@ -228,3 +249,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_experimental_detectron_prior_grid_generator_test_
                          experimental_detectron_prior_grid_generator_test_f16,
                          ::testing::ValuesIn(generateExperimentalPGGParams<half_t>()),
                          PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         experimental_detectron_prior_grid_generator_test_f16,
+                         ::testing::Values(generateExperimentalPGGParams<half_t>(true)[0]),
+                         PrintToStringParamName());
diff --git a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_roi_feature_extractor_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_roi_feature_extractor_gpu_test.cpp
index bb6051907b4569..559e773e516690 100644
--- a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_roi_feature_extractor_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_roi_feature_extractor_gpu_test.cpp
@@ -16,7 +16,8 @@
 using namespace cldnn;
 using namespace ::tests;
 
-TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
+template <typename T>
+void test_experimental_detectron_roi_feature_extractor_gpu_fp32_one_level(bool is_caching_test) {
     auto& engine = get_test_engine();
 
     const int rois_num = 2;
@@ -29,7 +30,7 @@ TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
     auto level_1 = engine.allocate_memory({data_types::f32, format::bfyx, {1, 2, 3, 2}});
     auto second_output = engine.allocate_memory({ data_types::f32, format::bfyx, tensor(batch(rois_num), feature(rois_feature_dim))});
 
-    std::vector<float> rois {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f};
+    std::vector<T> rois {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f};
     set_values(roi_input, rois);
     set_values(level_1, {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f});
 
@@ -52,31 +53,51 @@ TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
     topology.add(activation(activation_abs_id, feature_extractor_id,  activation_func::abs));
     topology.add(mutable_data(second_output_r_id, {feature_extractor_id}, second_output));
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data(input_rois_id, roi_input);
-    network.set_input_data(input_level_1_id, level_1);
+    network->set_input_data(input_rois_id, roi_input);
+    network->set_input_data(input_level_1_id, level_1);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
-    std::vector<float> expected_first_output {1.416667f, 1.75f, 2.083333f, 2.416667f, 2.75f, 3.083333f, 3.166667f, 3.5f,  3.833333f,
+    std::vector<T> expected_first_output {1.416667f, 1.75f, 2.083333f, 2.416667f, 2.75f, 3.083333f, 3.166667f, 3.5f,  3.833333f,
                                               7.416667f, 7.75f, 8.083333f, 8.416667f, 8.75f, 9.083334f, 9.166666f, 9.5f,  9.833334f,
                                               4.166667f, 4.5f,  4.833333f, 4.166667f, 4.5f,  4.833333f, 2.083333f, 2.25f, 2.416667f,
                                               10.16667f, 10.5f, 10.83333f, 10.16667f, 10.5f, 10.83333f, 5.083333f, 5.25f, 5.416667f};
 
     auto first_network_output = outputs.at(activation_abs_id).get_memory();
-    cldnn::mem_lock<float> first_output_ptr(first_network_output, get_test_stream());
+    cldnn::mem_lock<T> first_output_ptr(first_network_output, get_test_stream());
 
     ASSERT_EQ(expected_first_output.size(), first_output_ptr.size());
     for (std::size_t i = 0; i < expected_first_output.size(); i++) {
         EXPECT_FLOAT_EQ(expected_first_output[i], first_output_ptr[i]);
     }
 
-    std::vector<float>& expected_second_output = rois;
+    if (is_caching_test)
+        return;
+
+    std::vector<T>& expected_second_output = rois;
 
     auto second_network_output = outputs.at(second_output_r_id).get_memory();
     EXPECT_TRUE(engine.is_the_same_buffer(*second_output, *second_network_output));
-    cldnn::mem_lock<float> second_output_ptr(second_network_output, get_test_stream());
+    cldnn::mem_lock<T> second_output_ptr(second_network_output, get_test_stream());
 
     ASSERT_EQ(expected_second_output.size(), second_output_ptr.size());
     for (std::size_t i = 0; i < expected_second_output.size(); i++) {
@@ -84,6 +105,14 @@ TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
     }
 }
 
+TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
+    test_experimental_detectron_roi_feature_extractor_gpu_fp32_one_level<float>(false);
+}
+
+TEST(export_import_experimental_detectron_roi_feature_extractor_gpu_fp32, one_level) {
+    test_experimental_detectron_roi_feature_extractor_gpu_fp32_one_level<float>(true);
+}
+
 TEST(experimental_detectron_roi_feature_extractor_gpu_fp32, two_levels) {
     auto& engine = get_test_engine();
 
diff --git a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_topk_rois_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_topk_rois_gpu_test.cpp
index e6623410175810..56393694bf96f5 100644
--- a/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_topk_rois_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/experimental_detectron_topk_rois_gpu_test.cpp
@@ -107,7 +107,6 @@ TYPED_TEST(experimental_detectron_topk_rois_gpu_test, check_set_indices_layer_mo
 
     const std::string input_rois_id = "InputRois";
     const std::string input_indices_id = "InputIndices";
-    ;
     const std::string experimental_detectron_topk_rois_id = "experimental_detectron_topk_rois";
     topology topology;
     topology.add(input_layout(input_rois_id, roi_input->get_layout()));
@@ -131,3 +130,63 @@ TYPED_TEST(experimental_detectron_topk_rois_gpu_test, check_set_indices_layer_mo
     auto out_mem = result.at("plane_output").get_memory();
     this->checkOutput(out_mem, expected_output);
 }
+
+TEST(experimental_detectron_topk_rois_gpu_test, export_import) {
+    const auto test_format = format::bs_fs_yx_bsv32_fsv16;
+    const data_types test_data_type = type_to_data_type<float>::value;
+
+    auto& engine = get_test_engine();
+    // topk is more than model size
+    const int rois_num = 3;
+
+    auto roi_input = engine.allocate_memory({test_data_type, format::bfyx, tensor(batch(2), feature(4))});
+    auto roi_indices = engine.allocate_memory({data_types::i32, format::bfyx, tensor(batch(2), feature(1))});
+
+    std::vector<float> rois{1.0f, 1.0f, 4.0f, 5.0f, 3.0f, 2.0f, 7.0f, 9.0f};
+    set_values(roi_input, std::vector<float>(rois.begin(), rois.end()));
+    set_values(roi_indices, {1, 0});
+
+    const std::string input_rois_id = "InputRois";
+    const std::string input_indices_id = "InputIndices";
+    const std::string experimental_detectron_topk_rois_id = "experimental_detectron_topk_rois";
+    topology topology;
+    topology.add(input_layout(input_rois_id, roi_input->get_layout()));
+    topology.add(input_layout(input_indices_id, roi_indices->get_layout()));
+    topology.add(reorder("reordered_input", input_rois_id, test_format, test_data_type));
+    topology.add(reorder("reordered_indices", input_indices_id, test_format, data_types::i32));
+    topology.add(experimental_detectron_topk_rois(experimental_detectron_topk_rois_id,
+                                                  {"reordered_input", "reordered_indices"},
+                                                  rois_num));
+    topology.add(reorder("plane_output", experimental_detectron_topk_rois_id, format::bfyx, test_data_type));
+
+    cldnn::network::ptr network;
+
+    {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    }
+
+    network->set_input_data(input_rois_id, roi_input);
+    network->set_input_data(input_indices_id, roi_indices);
+
+    auto result = network->execute();
+
+    std::vector<float> expected_output{3.0f, 2.0f, 7.0f, 9.0f, 1.0f, 1.0f, 4.0f, 5.0f};
+
+    auto out_mem = result.at("plane_output").get_memory();
+    cldnn::mem_lock<float> out_ptr(out_mem, get_test_stream());
+    ASSERT_EQ(expected_output.size(), out_ptr.size());
+    for (size_t i = 0; i < expected_output.size(); ++i) {
+        EXPECT_NEAR(static_cast<float>(expected_output[i]), out_ptr[i], 0.0001) << "at i = " << i;
+    }
+}
\ No newline at end of file
diff --git a/src/plugins/intel_gpu/tests/test_cases/extract_image_patches_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/extract_image_patches_gpu_test.cpp
index 83bdc91d62f9e0..e1b2a37b84c074 100644
--- a/src/plugins/intel_gpu/tests/test_cases/extract_image_patches_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/extract_image_patches_gpu_test.cpp
@@ -490,7 +490,8 @@ TEST(extract_image_patches_gpu, basic4) {
     }
 }
 
-TEST(extract_image_patches_gpu, basic5) {
+template <typename T>
+void test_extract_image_patches_gpu_basic5(bool is_caching_test) {
     //  Input  : 1x2x5x5
     //  Output : 1x8x2x2
 
@@ -507,11 +508,11 @@ TEST(extract_image_patches_gpu, basic5) {
 
     auto input = engine.allocate_memory({ data_types::f32, format::bfyx, { batch, depth, in_cols, in_rows } });
 
-    std::vector<float> inputVals(batch * depth * in_rows * in_cols);
-    std::generate(inputVals.begin(), inputVals.end(), []() {
-        static float n = 1;
-        return n++;
-    });
+    std::vector<T> inputVals(batch * depth * in_rows * in_cols);
+    float n = 1;
+    for (auto& val : inputVals) {
+        val = n++;
+    }
 
     set_values(input, inputVals);
 
@@ -519,17 +520,35 @@ TEST(extract_image_patches_gpu, basic5) {
     topology.add(input_layout("Input0", input->get_layout()));
     topology.add(extract_image_patches("extract_image_patches", "Input0", sizes, strides, rates, auto_pad, output_shape));
 
-    network network(engine, topology);
-    network.set_input_data("Input0", input);
-    auto outputs = network.execute();
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("Input0", input);
+    auto outputs = network->execute();
 
     EXPECT_EQ(outputs.size(), size_t(1));
     EXPECT_EQ(outputs.begin()->first, "extract_image_patches");
 
     auto output = outputs.at("extract_image_patches").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
-    std::vector<float> answers = {
+    std::vector<T> answers = {
          1,  4,
         16, 19,
 
@@ -560,3 +579,11 @@ TEST(extract_image_patches_gpu, basic5) {
         EXPECT_TRUE(are_equal(answers[i], output_ptr[i])) << i;
     }
 }
+
+TEST(extract_image_patches_gpu, basic5) {
+    test_extract_image_patches_gpu_basic5<float>(false);
+}
+
+TEST(extract_image_patches_gpu, export_import) {
+    test_extract_image_patches_gpu_basic5<float>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/eye.cpp b/src/plugins/intel_gpu/tests/test_cases/eye.cpp
index 7b4485e403a8a3..9274b4f68309b4 100644
--- a/src/plugins/intel_gpu/tests/test_cases/eye.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/eye.cpp
@@ -22,7 +22,8 @@ using eye_test_param = std::tuple<format,                    // Input and output
                                   InputType,                 // diagonal index
                                   std::vector<InputType>,    // batch shape
                                   std::vector<int32_t>,      // output shape
-                                  std::vector<OutputType>>;  // expected values
+                                  std::vector<OutputType>,   // expected values
+                                  bool>;                     // is_caching_test
 
 template <class OutputType, class InputType>
 class EyeTest : public ::testing::TestWithParam<eye_test_param<OutputType, InputType>> {
@@ -35,8 +36,8 @@ class EyeTest : public ::testing::TestWithParam<eye_test_param<OutputType, Input
         std::vector<InputType> batch_shape;
         std::vector<int32_t> output_shape;
         std::vector<OutputType> expected_values;
-
-        std::tie(fmt, cols, rows, diag, batch_shape, output_shape, expected_values) = this->GetParam();
+        bool is_caching_test;
+        std::tie(fmt, cols, rows, diag, batch_shape, output_shape, expected_values, is_caching_test) = this->GetParam();
 
         auto num_rows = engine_.allocate_memory({type_to_data_type<InputType>::value, fmt, tensor{1}});
         set_values<InputType>(num_rows, {rows});
@@ -84,9 +85,26 @@ class EyeTest : public ::testing::TestWithParam<eye_test_param<OutputType, Input
             tp.add(reorder("output", "eye", oupput_fmt, type_to_data_type<OutputType>::value));
         }
 
-        network network(engine_, tp);
+        cldnn::network::ptr network; 
 
-        auto outputs = network.execute();
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine_, tp);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine_);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine_);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine_, tp);
+        }
+
+        auto outputs = network->execute();
 
         EXPECT_EQ(outputs.size(), size_t(1));
         EXPECT_EQ(outputs.begin()->first, ouput_op_name);
@@ -124,7 +142,8 @@ INSTANTIATE_TEST_SUITE_P(
                      testing::Values(0),
                      testing::ValuesIn(std::vector<std::vector<int32_t>>{{}, {1}, {1, 1}, {1, 1, 1}}),
                      testing::Values(std::vector<int32_t>{1, 1, 2, 3}),
-                     testing::Values(std::vector<float>{1, 0, 0, 1, 0, 0})));
+                     testing::Values(std::vector<float>{1, 0, 0, 1, 0, 0}),
+                     testing::Values(false)));
 
 using eye_test_4d_int64_int32 = EyeTest<int64_t, int32_t>;
 TEST_P(eye_test_4d_int64_int32, eye_test_4d_int64_int32) {}
@@ -137,7 +156,8 @@ INSTANTIATE_TEST_SUITE_P(
                      testing::Values(0),
                      testing::ValuesIn(std::vector<std::vector<int32_t>>{{}, {1}, {1, 1}, {1, 1, 1}}),
                      testing::Values(std::vector<int32_t>{1, 1, 2, 3}),
-                     testing::Values(std::vector<int64_t>{1, 0, 0, 1, 0, 0})));
+                     testing::Values(std::vector<int64_t>{1, 0, 0, 1, 0, 0}),
+                     testing::Values(false)));
 
 using eye_test_4d_u8_int64 = EyeTest<uint8_t, int64_t>;
 TEST_P(eye_test_4d_u8_int64, eye_test_4d_u8_int64) {}
@@ -150,7 +170,8 @@ INSTANTIATE_TEST_SUITE_P(
                      testing::Values(-1),
                      testing::ValuesIn(std::vector<std::vector<int64_t>>{{}, {1}, {1, 1}, {1, 1, 1}}),
                      testing::Values(std::vector<int32_t>{1, 1, 4, 3}),
-                     testing::Values(std::vector<uint8_t>{0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0})));
+                     testing::Values(std::vector<uint8_t>{0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0}),
+                     testing::Values(false)));
 
 using eye_test_4d_i8_int64_no_diag = EyeTest<int8_t, int64_t>;
 TEST_P(eye_test_4d_i8_int64_no_diag, eye_test_4d_i8_int64_no_diag) {}
@@ -163,7 +184,8 @@ INSTANTIATE_TEST_SUITE_P(
                      testing::Values(4),
                      testing::ValuesIn(std::vector<std::vector<int64_t>>{{}, {1}, {1, 1}, {1, 1, 1}}),
                      testing::Values(std::vector<int32_t>{1, 1, 4, 3}),
-                     testing::Values(std::vector<int8_t>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})));
+                     testing::Values(std::vector<int8_t>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+                     testing::Values(false)));
 
 using eye_test_4d_int32_int32_batch = EyeTest<int32_t, int32_t>;
 TEST_P(eye_test_4d_int32_int32_batch, eye_test_4d_int32_int32_batch) {}
@@ -176,7 +198,8 @@ INSTANTIATE_TEST_SUITE_P(
                      testing::Values(1),
                      testing::ValuesIn(std::vector<std::vector<int32_t>>{{2, 2}}),
                      testing::Values(std::vector<int32_t>{2, 2, 2, 2}),
-                     testing::Values(std::vector<int32_t>{0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0})));
+                     testing::Values(std::vector<int32_t>{0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0}),
+                     testing::Values(false)));
 
 std::vector<format> five_d_formats{
     format::bfzyx,
@@ -192,7 +215,22 @@ using eye_test_5d_float_int32 = EyeTest<float, int32_t>;
 TEST_P(eye_test_5d_float_int32, eye_test_5d_float_int32) {}
 INSTANTIATE_TEST_SUITE_P(eye_test_5d_float_int32,
                          eye_test_5d_float_int32,
-                         testing::Combine(testing::ValuesIn(five_d_formats),
+                         testing::Combine(testing::Values(five_d_formats[0]),
+                                          testing::Values(2),
+                                          testing::Values(2),
+                                          testing::Values(0),
+                                          testing::ValuesIn(std::vector<std::vector<int32_t>>{{2, 2, 2}}),
+                                          testing::Values(std::vector<int32_t>{2, 2, 2, 2, 2}),
+                                          testing::Values(std::vector<float>{
+                                              1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+
+                                              1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+                                          }),
+                                          testing::Values(false)));
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         eye_test_5d_float_int32,
+                         testing::Combine(testing::Values(five_d_formats[0]),
                                           testing::Values(2),
                                           testing::Values(2),
                                           testing::Values(0),
@@ -202,6 +240,7 @@ INSTANTIATE_TEST_SUITE_P(eye_test_5d_float_int32,
                                               1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
 
                                               1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
-                                          })));
+                                          }),
+                                          testing::Values(true)));
 
 }  // anonymous namespace
diff --git a/src/plugins/intel_gpu/tests/test_cases/fully_connected_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/fully_connected_gpu_test.cpp
index 38279ae3a68ef6..05c5454c30645f 100644
--- a/src/plugins/intel_gpu/tests/test_cases/fully_connected_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/fully_connected_gpu_test.cpp
@@ -979,7 +979,8 @@ using fully_connected_test_params = std::tuple<
     size_t,        // output_f
     format::type,  // input format
     format::type,  // output format
-    std::string    // kernel
+    std::string,   // kernel
+    bool           // is_caching_test
 >;
 
 template <typename InputT, typename WeightsT, typename BiasT, typename OutputT>
@@ -989,8 +990,9 @@ struct fully_connected_random_test : ::testing::TestWithParam<fully_connected_te
         size_t batch, input_f, input_x, input_y, output_f;
         format::type input_format, output_format;
         std::string kernel;
+        bool is_caching_test;
 
-        std::tie(batch, dims, output_f, input_format, output_format, kernel) = GetParam();
+        std::tie(batch, dims, output_f, input_format, output_format, kernel, is_caching_test) = GetParam();
         std::tie(input_f, input_x, input_y) = dims;
 
         auto input_data = generate_smart_random_4d<InputT>(batch, input_f, input_y, input_x);
@@ -1004,7 +1006,7 @@ struct fully_connected_random_test : ::testing::TestWithParam<fully_connected_te
         auto bias = net.add_data<BiasT, 2>("bias", format::bfyx, std::move(bias_data));
         auto fc = net.add_fully_connected<OutputT>("fc_prim", input, weights, bias, implementation_desc{ output_format, kernel });
 
-        net.run(build_options(build_option::optimize_data(true)));
+        net.run(build_options(build_option::optimize_data(true)), is_caching_test);
     }
 };
 
@@ -1025,7 +1027,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx, format::yxfb),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1038,7 +1041,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::bfyx),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 TEST_P(fully_connected_random_test_f16, basic) {
@@ -1057,7 +1061,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1070,7 +1075,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::yxfb),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1083,9 +1089,22 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(3, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::bfyx),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
+INSTANTIATE_TEST_SUITE_P(
+    export_import,
+    fully_connected_random_test_f16,
+    ::testing::Combine(
+        ::testing::Values(2),
+        ::testing::Values(shared_dims{32, 1, 1}),
+        ::testing::Values(32),
+        ::testing::Values(format::bfyx),
+        ::testing::Values(format::bfyx),
+        ::testing::Values(""),
+        ::testing::Values(true))
+);
 
 template <typename InputT, typename WeightsT, typename BiasT, typename OutputT>
 struct fully_connected_random_test_3d : ::testing::TestWithParam<fully_connected_test_params> {
@@ -1094,8 +1113,9 @@ struct fully_connected_random_test_3d : ::testing::TestWithParam<fully_connected
         size_t batch, input_f, input_x, input_y, output_y;
         format::type input_format, output_format;
         std::string kernel;
+        bool is_caching_test;
 
-        std::tie(batch, dims, output_y, input_format, output_format, kernel) = GetParam();
+        std::tie(batch, dims, output_y, input_format, output_format, kernel, is_caching_test) = GetParam();
         std::tie(input_f, input_x, input_y) = dims;
 
         auto input_data = generate_smart_random_4d<InputT>(batch, input_f, input_y, input_x);
@@ -1109,7 +1129,7 @@ struct fully_connected_random_test_3d : ::testing::TestWithParam<fully_connected
         auto bias = net.add_data<BiasT, 2>("bias", format::bfyx, std::move(bias_data));
         auto fc = net.add_fully_connected_3d<OutputT>("fc_prim", input, weights, bias, implementation_desc{ output_format, kernel }, 3);
 
-        net.run(build_options(build_option::optimize_data(true)));
+        net.run(build_options(build_option::optimize_data(true)), is_caching_test);
     }
 };
 
@@ -1134,7 +1154,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1149,7 +1170,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 32, 64),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1164,7 +1186,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(17, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 TEST_P(fully_connected_random_test_f16_3d, basic) {
@@ -1183,7 +1206,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 TEST_P(fully_connected_random_test_i8_3d, basic) {
@@ -1202,7 +1226,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 3, 16),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1217,7 +1242,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(1, 32, 64),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1232,7 +1258,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(17, 32),
         ::testing::Values(format::bfyx),
         ::testing::Values(format::any),
-        ::testing::Values(""))
+        ::testing::Values(""),
+        ::testing::Values(false))
 );
 
 
diff --git a/src/plugins/intel_gpu/tests/test_cases/gather_elements_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/gather_elements_gpu_test.cpp
index 3458d644b3a642..ac312e69b7bf5d 100644
--- a/src/plugins/intel_gpu/tests/test_cases/gather_elements_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/gather_elements_gpu_test.cpp
@@ -21,7 +21,8 @@ inline void DoTest(engine& engine,
     const cldnn::memory::ptr& input1, // indices
     const std::vector<float>& expected_results,
     const tensor& output_tensor,
-    const int64_t axis) {
+    const int64_t axis,
+    bool is_caching_test=false) {
     topology topology;
     topology.add(input_layout("InputData", input0->get_layout()));
     topology.add(input_layout("InputIndices", input1->get_layout()));
@@ -29,11 +30,28 @@ inline void DoTest(engine& engine,
         gather_elements("gather_elements", "InputData", "InputIndices", input1->get_layout().format, output_tensor, axis)
     );
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
 
-    network.set_input_data("InputData", input0);
-    network.set_input_data("InputIndices", input1);
-    auto outputs = network.execute();
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
+
+    network->set_input_data("InputData", input0);
+    network->set_input_data("InputIndices", input1);
+    auto outputs = network->execute();
     auto output = outputs.at("gather_elements").get_memory();
     cldnn::mem_lock<uint16_t> output_ptr(output, get_test_stream());
 
@@ -1137,5 +1155,102 @@ TEST(gather_elements_gpu_fp16, d233113_i233115_a2) {
         FLOAT16(5), FLOAT16(6), FLOAT16(3),
     };
 
-    DoTest(engine, input0, input1, expected_results, tensor(2, 3, 3, 1, 1, 5), axis);
+    DoTest(engine, input0, input1, expected_results, tensor(2, 3, 3, 1, 1, 5), axis, false);
+}
+
+TEST(gather_elements_gpu_fp16, export_import) {
+    auto& engine = get_test_engine();
+
+    auto axis = 2;
+    auto input0 = engine.allocate_memory({ data_types::f16, format::bfwzyx, { 2, 3, 3, 1, 1, 3 } }); // data
+    auto input1 = engine.allocate_memory({ data_types::f16, format::bfwzyx, { 2, 3, 3, 1, 1, 5 } }); // indices
+
+    set_values(input0, {
+        FLOAT16(0), FLOAT16(1), FLOAT16(8),
+        FLOAT16(5), FLOAT16(5), FLOAT16(2),
+        FLOAT16(0), FLOAT16(7), FLOAT16(7),
+        FLOAT16(10), FLOAT16(4), FLOAT16(5),
+        FLOAT16(9), FLOAT16(0), FLOAT16(0),
+        FLOAT16(5), FLOAT16(7), FLOAT16(0),
+        FLOAT16(4), FLOAT16(0), FLOAT16(4),
+        FLOAT16(7), FLOAT16(6), FLOAT16(10),
+        FLOAT16(9), FLOAT16(5), FLOAT16(1),
+        FLOAT16(7), FLOAT16(4), FLOAT16(7),
+        FLOAT16(10), FLOAT16(8), FLOAT16(2),
+        FLOAT16(0), FLOAT16(8), FLOAT16(3),
+        FLOAT16(6), FLOAT16(8), FLOAT16(10),
+        FLOAT16(4), FLOAT16(2), FLOAT16(10),
+        FLOAT16(7), FLOAT16(8), FLOAT16(7),
+        FLOAT16(0), FLOAT16(6), FLOAT16(9),
+        FLOAT16(2), FLOAT16(4), FLOAT16(8),
+        FLOAT16(5), FLOAT16(2), FLOAT16(3),
+    });
+
+    set_values(input1, {
+        FLOAT16(0), FLOAT16(1), FLOAT16(2),
+        FLOAT16(2), FLOAT16(2), FLOAT16(0),
+        FLOAT16(0), FLOAT16(0), FLOAT16(2),
+        FLOAT16(0), FLOAT16(0), FLOAT16(0),
+        FLOAT16(1), FLOAT16(0), FLOAT16(1),
+        FLOAT16(1), FLOAT16(2), FLOAT16(1),
+        FLOAT16(2), FLOAT16(1), FLOAT16(2),
+        FLOAT16(1), FLOAT16(0), FLOAT16(2),
+        FLOAT16(1), FLOAT16(0), FLOAT16(1),
+        FLOAT16(2), FLOAT16(0), FLOAT16(0),
+        FLOAT16(1), FLOAT16(2), FLOAT16(2),
+        FLOAT16(1), FLOAT16(1), FLOAT16(1),
+        FLOAT16(1), FLOAT16(0), FLOAT16(2),
+        FLOAT16(0), FLOAT16(2), FLOAT16(2),
+        FLOAT16(2), FLOAT16(2), FLOAT16(2),
+        FLOAT16(0), FLOAT16(0), FLOAT16(2),
+        FLOAT16(1), FLOAT16(2), FLOAT16(2),
+        FLOAT16(2), FLOAT16(2), FLOAT16(0),
+        FLOAT16(2), FLOAT16(0), FLOAT16(0),
+        FLOAT16(0), FLOAT16(0), FLOAT16(2),
+        FLOAT16(2), FLOAT16(0), FLOAT16(1),
+        FLOAT16(1), FLOAT16(2), FLOAT16(2),
+        FLOAT16(1), FLOAT16(1), FLOAT16(0),
+        FLOAT16(2), FLOAT16(0), FLOAT16(0),
+        FLOAT16(0), FLOAT16(2), FLOAT16(2),
+        FLOAT16(2), FLOAT16(1), FLOAT16(0),
+        FLOAT16(0), FLOAT16(2), FLOAT16(1),
+        FLOAT16(2), FLOAT16(1), FLOAT16(2),
+        FLOAT16(0), FLOAT16(0), FLOAT16(1),
+        FLOAT16(2), FLOAT16(0), FLOAT16(2),
+    });
+
+    std::vector<float> expected_results = {
+        FLOAT16(0), FLOAT16(5), FLOAT16(7),
+        FLOAT16(0), FLOAT16(7), FLOAT16(8),
+        FLOAT16(0), FLOAT16(1), FLOAT16(7),
+        FLOAT16(0), FLOAT16(1), FLOAT16(8),
+        FLOAT16(5), FLOAT16(1), FLOAT16(2),
+        FLOAT16(9), FLOAT16(7), FLOAT16(0),
+        FLOAT16(5), FLOAT16(0), FLOAT16(0),
+        FLOAT16(9), FLOAT16(4), FLOAT16(0),
+        FLOAT16(9), FLOAT16(4), FLOAT16(0),
+        FLOAT16(5), FLOAT16(4), FLOAT16(5),
+        FLOAT16(7), FLOAT16(5), FLOAT16(1),
+        FLOAT16(7), FLOAT16(6), FLOAT16(10),
+        FLOAT16(7), FLOAT16(0), FLOAT16(1),
+        FLOAT16(4), FLOAT16(5), FLOAT16(1),
+        FLOAT16(9), FLOAT16(5), FLOAT16(1),
+        FLOAT16(7), FLOAT16(4), FLOAT16(3),
+        FLOAT16(10), FLOAT16(8), FLOAT16(3),
+        FLOAT16(0), FLOAT16(8), FLOAT16(7),
+        FLOAT16(0), FLOAT16(4), FLOAT16(7),
+        FLOAT16(7), FLOAT16(4), FLOAT16(3),
+        FLOAT16(7), FLOAT16(8), FLOAT16(10),
+        FLOAT16(4), FLOAT16(8), FLOAT16(7),
+        FLOAT16(4), FLOAT16(2), FLOAT16(10),
+        FLOAT16(7), FLOAT16(8), FLOAT16(10),
+        FLOAT16(6), FLOAT16(8), FLOAT16(7),
+        FLOAT16(5), FLOAT16(4), FLOAT16(9),
+        FLOAT16(0), FLOAT16(2), FLOAT16(8),
+        FLOAT16(5), FLOAT16(4), FLOAT16(3),
+        FLOAT16(0), FLOAT16(6), FLOAT16(8),
+        FLOAT16(5), FLOAT16(6), FLOAT16(3),
+    };
+
+    DoTest(engine, input0, input1, expected_results, tensor(2, 3, 3, 1, 1, 5), axis, true);
 }
diff --git a/src/plugins/intel_gpu/tests/test_cases/gather_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/gather_gpu_test.cpp
index ba59df945647d6..60f51b2d6e2dbc 100644
--- a/src/plugins/intel_gpu/tests/test_cases/gather_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/gather_gpu_test.cpp
@@ -1868,7 +1868,8 @@ TEST(gather_gpu_fp32, 322_axisF) {
     }
 }
 
-TEST(gather_gpu_u8, 322_axisF) {
+template <typename T>
+void test_gather_gpu_u8_322_axisF(bool is_caching_test) {
     //  Dictionary : 3x3x1x1
     //  Indexes : 2x2x1x1
     //  Axis : 1
@@ -1881,7 +1882,7 @@ TEST(gather_gpu_u8, 322_axisF) {
     auto input2 = engine.allocate_memory({data_types::i32, format::bfyx, tensor{2, 2, 1, 1}}); // Indexes
     int64_t axis = 1;
 
-    set_values<uint8_t>(input1, {0, 1, 2, 10, 11, 12, 20, 21, 22});
+    set_values<T>(input1, {0, 1, 2, 10, 11, 12, 20, 21, 22});
 
     set_values(input2, {1, 0,
                         2, 1});
@@ -1892,17 +1893,34 @@ TEST(gather_gpu_u8, 322_axisF) {
     topology.add(
         gather("gather", "InputDictionary", "InputText", axis, ov::Shape{3, 2, 2, 1}));
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("InputDictionary", input1);
-    network.set_input_data("InputText", input2);
+    network->set_input_data("InputDictionary", input1);
+    network->set_input_data("InputText", input2);
 
-    auto outputs = network.execute();
+    auto outputs = network->execute();
 
     auto output = outputs.at("gather").get_memory();
-    cldnn::mem_lock<uint8_t> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
 
-    std::vector<uint8_t> expected_results = {
+    std::vector<T> expected_results = {
         1, 0, 2, 1, 11, 10, 12, 11, 21, 20, 22, 21};
 
     ASSERT_EQ(expected_results.size(), output_ptr.size());
@@ -1910,3 +1928,11 @@ TEST(gather_gpu_u8, 322_axisF) {
         EXPECT_EQ(expected_results[i], output_ptr[i]) << i;
     }
 }
+
+TEST(gather_gpu_u8, 322_axisF) {
+    test_gather_gpu_u8_322_axisF<uint8_t>(false);
+}
+
+TEST(gather_gpu_u8, export_import) {
+    test_gather_gpu_u8_322_axisF<uint8_t>(true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/gather_nd_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/gather_nd_gpu_test.cpp
index f5a89368b5eaff..88fec5921d0f66 100644
--- a/src/plugins/intel_gpu/tests/test_cases/gather_nd_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/gather_nd_gpu_test.cpp
@@ -19,7 +19,8 @@ inline void DoTestBase(engine& engine,
     const int batch_dims,
     const cldnn::format fmt,
     const tensor ts,
-    const bool batch_merged_output) {
+    const bool batch_merged_output,
+    bool is_caching_test=false) {
     topology topology;
 
     int input_rank = 0;
@@ -38,11 +39,28 @@ inline void DoTestBase(engine& engine,
     topology.add(input_layout("InputIndices", input1->get_layout()));
     topology.add(gather_nd_inst);
 
-    network network(engine, topology);
+    cldnn::network::ptr network;
+
+    if (is_caching_test) {
+        membuf mem_buf;
+        {
+            cldnn::network _network(engine, topology);
+            std::ostream out_mem(&mem_buf);
+            BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+            _network.save(ob);
+        }
+        {
+            std::istream in_mem(&mem_buf);
+            BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+            network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+        }
+    } else {
+        network = std::make_shared<cldnn::network>(engine, topology);
+    }
 
-    network.set_input_data("InputData", input0);
-    network.set_input_data("InputIndices", input1);
-    auto outputs = network.execute();
+    network->set_input_data("InputData", input0);
+    network->set_input_data("InputIndices", input1);
+    auto outputs = network->execute();
     auto output = outputs.at("gather_nd").get_memory();
 
     // Compare output shape
@@ -77,8 +95,9 @@ inline void DoTestV5(engine& engine,
     const int indices_rank,
     const int batch_dims,
     const cldnn::format fmt,
-    const tensor size) {
-    DoTestBase(engine, input0, input1, expected_results, indices_rank, batch_dims, fmt, size, true);
+    const tensor size,
+    bool is_caching_test=false) {
+    DoTestBase(engine, input0, input1, expected_results, indices_rank, batch_dims, fmt, size, true, is_caching_test);
 }
 
 inline void DoTestV8(engine& engine,
@@ -88,8 +107,9 @@ inline void DoTestV8(engine& engine,
     const int indices_rank,
     const int batch_dims,
     const cldnn::format fmt,
-    const tensor size) {
-    DoTestBase(engine, input0, input1, expected_results, indices_rank, batch_dims, fmt, size, false);
+    const tensor size,
+    bool is_caching_test=false) {
+    DoTestBase(engine, input0, input1, expected_results, indices_rank, batch_dims, fmt, size, false, is_caching_test);
 }
 
 TEST(gather_nd_gpu_fp16, d23322_i231312_ir6_batch2) {
@@ -747,3 +767,33 @@ TEST(gather_nd_gpu_fp16, d22_i32_ir2_batch0) {
     DoTestV5(engine,input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 });
     DoTestV8(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 });
 }
+
+TEST(gather_nd_gpu_fp16, export_import) {
+    auto& engine = get_test_engine();
+
+    const int indices_rank = 2;
+    const int batch_dims = 0;
+    auto input0 = engine.allocate_memory({ data_types::f16, format::bfyx, { 2, 2, 1, 1 } }); // data
+    auto input1 = engine.allocate_memory({ data_types::f16, format::bfyx, { 3, 2, 1, 1 } }); // indices
+    // expected output dim: {3,1,1}
+
+    set_values(input0, {
+        FLOAT16(1), FLOAT16(2),
+        FLOAT16(3), FLOAT16(4)
+    });
+
+    set_values(input1, {
+        FLOAT16(0), FLOAT16(0),
+        FLOAT16(1), FLOAT16(0),
+        FLOAT16(1), FLOAT16(1),
+    });
+
+    std::vector<float> expected_results = {
+        FLOAT16(1),
+        FLOAT16(3),
+        FLOAT16(4),
+    };
+
+    DoTestV5(engine,input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 }, true);
+    DoTestV8(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 }, true);
+}
diff --git a/src/plugins/intel_gpu/tests/test_cases/gather_tree_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/gather_tree_gpu_test.cpp
index 8fbe6a3fc455b4..5d5627922be6de 100644
--- a/src/plugins/intel_gpu/tests/test_cases/gather_tree_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/gather_tree_gpu_test.cpp
@@ -37,7 +37,8 @@ template<typename T>
 using ParamsWithLayout = std::tuple<
     Params<T>,
     format::type,   // source (plain) layout - bfyx
-    format::type    // target (blocked) layout
+    format::type,   // target (blocked) layout
+    bool            // is_caching_test
 >;
 
 const std::vector<format::type> layouts = {
@@ -153,10 +154,12 @@ struct PrintToStringParamName {
         Params<T> p;
         format::type plain_layout;
         format::type target_layout;
-        std::tie(p, plain_layout, target_layout) = param.param;
+        bool is_caching_test;
+        std::tie(p, plain_layout, target_layout, is_caching_test) = param.param;
         buf << " test case " << p.testcase_name
             << " plain layout " << plain_layout
-            << " target layout " << target_layout;
+            << " target layout " << target_layout
+            << " is_caching_test " << is_caching_test;
         return buf.str();
     }
 };
@@ -171,8 +174,9 @@ struct gather_tree_test
         Params<T> params;
         format::type plain_layout;
         format::type target_layout;
+        bool is_caching_test;
 
-        std::tie(params, plain_layout, target_layout) = this->GetParam();
+        std::tie(params, plain_layout, target_layout, is_caching_test) = this->GetParam();
 
         auto &engine = get_test_engine();
         topology topology;
@@ -211,14 +215,31 @@ struct gather_tree_test
         const primitive_id reorder_result_id = result_id + "_reordered";
         topology.add(reorder(reorder_result_id, result_id, plain_layout, data_type));
 
-        network network(engine, topology);
+        cldnn::network::ptr network;
 
-        network.set_input_data(step_id, step_input);
-        network.set_input_data(parent_id, parent_input);
-        network.set_input_data(max_seq_len_id, max_seq_len_input);
-        network.set_input_data(end_token_id, end_token_input);
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data(step_id, step_input);
+        network->set_input_data(parent_id, parent_input);
+        network->set_input_data(max_seq_len_id, max_seq_len_input);
+        network->set_input_data(end_token_id, end_token_input);
 
-        auto result = network.execute();
+        auto result = network->execute();
 
         auto out_mem = result.at(reorder_result_id).get_memory();
         cldnn::mem_lock<T> out_ptr(out_mem, get_test_stream());
@@ -247,7 +268,8 @@ INSTANTIATE_TEST_SUITE_P(gather_tree,
                          ::testing::Combine(
                              ::testing::ValuesIn(generateParams<float>()),
                              ::testing::Values(format::bfyx),
-                             ::testing::ValuesIn(layouts)),
+                             ::testing::ValuesIn(layouts),
+                             ::testing::Values(false)),
                          PrintToStringParamName());
 
 INSTANTIATE_TEST_SUITE_P(gather_tree,
@@ -255,5 +277,15 @@ INSTANTIATE_TEST_SUITE_P(gather_tree,
                          ::testing::Combine(
                              ::testing::ValuesIn(generateParams<int32_t>()),
                              ::testing::Values(format::bfyx),
-                             ::testing::ValuesIn(layouts)),
+                             ::testing::ValuesIn(layouts),
+                             ::testing::Values(false)),
+                         PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(export_import,
+                         gather_tree_test_int32,
+                         ::testing::Combine(
+                             ::testing::Values(generateParams<int32_t>()[0]),
+                             ::testing::Values(format::bfyx),
+                             ::testing::Values(layouts[0]),
+                             ::testing::Values(true)),
                          PrintToStringParamName());
diff --git a/src/plugins/intel_gpu/tests/test_cases/generate_proposals_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/generate_proposals_gpu_test.cpp
index dcc8bf7d88a994..1690f37de8a8be 100644
--- a/src/plugins/intel_gpu/tests/test_cases/generate_proposals_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/generate_proposals_gpu_test.cpp
@@ -26,7 +26,7 @@ struct GenerateProposalsParams {
 };
 
 template <typename T>
-using GenerateProposalsParamsWithLayout = std::tuple<GenerateProposalsParams<T>, format::type>;
+using GenerateProposalsParamsWithLayout = std::tuple<GenerateProposalsParams<T>, format::type, bool>;
 
 constexpr size_t num_batches = 2;
 constexpr size_t image_height = 200;
@@ -282,7 +282,8 @@ struct generate_proposals_test
     void test() {
         GenerateProposalsParams<T> param;
         format::type data_layout;
-        std::tie(param, data_layout) = this->GetParam();
+        bool is_caching_test;
+        std::tie(param, data_layout, is_caching_test) = this->GetParam();
         const bool need_reorder = data_layout != format::bfyx;
 
         const auto data_type = type_to_data_type<T>::value;
@@ -355,14 +356,31 @@ struct generate_proposals_test
         const primitive_id reorder_result_id = generate_proposals_id + "Reordered";
         topology.add(reorder(reorder_result_id, generate_proposals_id, format::bfyx, data_type));
 
-        network network{engine, topology};
+        cldnn::network::ptr network;
 
-        network.set_input_data(input_im_info_id, input_im_info);
-        network.set_input_data(input_anchors_id, input_anchors);
-        network.set_input_data(input_deltas_id, input_deltas);
-        network.set_input_data(input_scores_id, input_scores);
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(engine, topology);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, engine);
+                network = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), engine);
+            }
+        } else {
+            network = std::make_shared<cldnn::network>(engine, topology);
+        }
+
+        network->set_input_data(input_im_info_id, input_im_info);
+        network->set_input_data(input_anchors_id, input_anchors);
+        network->set_input_data(input_deltas_id, input_deltas);
+        network->set_input_data(input_scores_id, input_scores);
 
-        const auto outputs = network.execute();
+        const auto outputs = network->execute();
 
         const auto rois = outputs.at(reorder_result_id).get_memory();
 
@@ -395,13 +413,16 @@ struct generate_proposals_test
         const auto& expected_roi_scores = param.expected_roi_scores;
         const auto& expected_rois_num = param.expected_rois_num;
 
-        for (size_t j = 0; j < expected_rois_num.size(); ++j) {
-            EXPECT_EQ(expected_rois_num[j], rois_num_ptr[j]) << "j=" << j;
+        if (!is_caching_test) {
+            for (size_t j = 0; j < expected_rois_num.size(); ++j) {
+                EXPECT_EQ(expected_rois_num[j], rois_num_ptr[j]) << "j=" << j;
+            }
         }
 
         for (auto i = 0; i < param.post_nms_count; ++i) {
-            EXPECT_NEAR(expected_roi_scores[i], roi_scores_ptr[i], getError<T>()) << "i=" << i;
-
+            if (!is_caching_test) {
+                EXPECT_NEAR(expected_roi_scores[i], roi_scores_ptr[i], getError<T>()) << "i=" << i;
+            }
             if (static_cast<float>(expected_roi_scores[i]) != 0.0f) {
                 for (size_t coord = 0; coord < 4; ++coord) {
                     const auto roi_idx = i * 4 + coord;
@@ -421,7 +442,8 @@ INSTANTIATE_TEST_SUITE_P(
         f32_i32,
         ::testing::Combine(
             ::testing::ValuesIn(getGenerateProposalsParams<float>()),
-            ::testing::ValuesIn(layouts)
+            ::testing::ValuesIn(layouts),
+            ::testing::Values(false)
             ));
 
 using f32_i64 = generate_proposals_test<float, int64_t>;
@@ -433,7 +455,8 @@ INSTANTIATE_TEST_SUITE_P(
         f32_i64,
         ::testing::Combine(
                 ::testing::ValuesIn(getGenerateProposalsParams<float>()),
-                ::testing::ValuesIn(layouts)
+                ::testing::ValuesIn(layouts),
+                ::testing::Values(false)
         ));
 
 using f16_i32 = generate_proposals_test<half_t, int32_t>;
@@ -445,7 +468,8 @@ INSTANTIATE_TEST_SUITE_P(
         f16_i32,
         ::testing::Combine(
                 ::testing::ValuesIn(getGenerateProposalsParams<half_t>()),
-                ::testing::ValuesIn(layouts)
+                ::testing::ValuesIn(layouts),
+                ::testing::Values(false)
         ));
 
 using f16_i64 = generate_proposals_test<half_t, int64_t>;
@@ -457,5 +481,15 @@ INSTANTIATE_TEST_SUITE_P(
         f16_i64,
         ::testing::Combine(
                 ::testing::ValuesIn(getGenerateProposalsParams<half_t>()),
-                ::testing::ValuesIn(layouts)
+                ::testing::ValuesIn(layouts),
+                ::testing::Values(false)
+        ));
+
+INSTANTIATE_TEST_SUITE_P(
+        export_import_generate_proposals_gpu_test,
+        f16_i64,
+        ::testing::Combine(
+                ::testing::Values(getGenerateProposalsParams<half_t>()[0]),
+                ::testing::Values(layouts[0]),
+                ::testing::Values(true)
         ));
diff --git a/src/plugins/intel_gpu/tests/test_utils/network_test.h b/src/plugins/intel_gpu/tests/test_utils/network_test.h
index 7b11a2ba1c589b..e19c0f2e75adfa 100644
--- a/src/plugins/intel_gpu/tests/test_utils/network_test.h
+++ b/src/plugins/intel_gpu/tests/test_utils/network_test.h
@@ -338,25 +338,45 @@ class network_test {
         return add_node(id, reference_tensor_typed<T, 4>(output_data), {input, weights, bias});
     }
 
-    cldnn::network::ptr build_network(cldnn::build_options opts) {
+    cldnn::network::ptr build_network(cldnn::build_options opts, bool is_caching_test=false) {
         opts.set_option(cldnn::build_option::force_implementations(forced_impls));
-        auto net = cldnn::network::build_network(eng, topo, opts);
+        cldnn::network::ptr net;
+
+        if (is_caching_test) {
+            membuf mem_buf;
+            {
+                cldnn::network _network(eng, topo, opts);
+                std::ostream out_mem(&mem_buf);
+                BinaryOutputBuffer ob = BinaryOutputBuffer(out_mem);
+                _network.save(ob);
+            }
+            {
+                std::istream in_mem(&mem_buf);
+                BinaryInputBuffer ib = BinaryInputBuffer(in_mem, eng);
+                net = std::make_shared<cldnn::network>(ib, get_test_stream_ptr(), eng);
+            }
+        } else {
+            net = std::make_shared<cldnn::network>(eng, topo, opts);
+        }
+
         for (auto& in_data : inputs) {
             net->set_input_data(in_data.first, in_data.second);
         }
         return net;
     }
 
-    void run(cldnn::build_options opts) {
-        auto net = build_network(opts);
-        std::stringstream network_info;
-        network_info << "Executed kernels: " << std::endl;
-        for (auto info : net->get_primitives_info()) {
-            if (info.kernel_id == "")
-                continue;
-            network_info << "  " << info.original_id << " " << info.kernel_id << std::endl;
+    void run(cldnn::build_options opts, bool is_caching_test=false) {
+        auto net = build_network(opts, is_caching_test);
+        if (!is_caching_test) {
+            std::stringstream network_info;
+            network_info << "Executed kernels: " << std::endl;
+            for (auto info : net->get_primitives_info()) {
+                if (info.kernel_id == "")
+                    continue;
+                network_info << "  " << info.original_id << " " << info.kernel_id << std::endl;
+            }
+            SCOPED_TRACE("\n" + network_info.str());
         }
-        SCOPED_TRACE("\n" + network_info.str());
 
         auto result = net->execute();
         for (auto out : result) {
diff --git a/src/plugins/intel_gpu/tests/test_utils/test_utils.cpp b/src/plugins/intel_gpu/tests/test_utils/test_utils.cpp
index 49a0fdb7f56421..64c1a9ec97e891 100644
--- a/src/plugins/intel_gpu/tests/test_utils/test_utils.cpp
+++ b/src/plugins/intel_gpu/tests/test_utils/test_utils.cpp
@@ -328,11 +328,15 @@ cldnn::engine& get_onednn_test_engine() {
 }
 #endif
 
-cldnn::stream& get_test_stream() {
+cldnn::stream_ptr get_test_stream_ptr() {
     static std::shared_ptr<cldnn::stream> test_stream = nullptr;
     if (!test_stream)
         test_stream = get_test_engine().create_stream();
-    return *test_stream;
+    return test_stream;
+}
+
+cldnn::stream& get_test_stream() {
+    return *get_test_stream_ptr();
 }
 
 const std::string test_dump::name() const {
diff --git a/src/plugins/intel_gpu/tests/test_utils/test_utils.h b/src/plugins/intel_gpu/tests/test_utils/test_utils.h
index c88a1c970aaec4..4dc2268946207f 100644
--- a/src/plugins/intel_gpu/tests/test_utils/test_utils.h
+++ b/src/plugins/intel_gpu/tests/test_utils/test_utils.h
@@ -58,6 +58,7 @@ cldnn::engine& get_test_engine(const cldnn::engine_configuration& configuration)
 #ifdef ENABLE_ONEDNN_FOR_GPU
 cldnn::engine& get_onednn_test_engine();
 #endif
+cldnn::stream_ptr get_test_stream_ptr();
 cldnn::stream& get_test_stream();
 
 template<typename T>
@@ -571,6 +572,25 @@ T div_up(const T a, const U b) {
 
 double default_tolerance(data_types dt);
 
+class membuf : public std::streambuf
+{
+public:
+    membuf() : _pos(0) { }
+
+protected:
+    virtual int_type overflow (int_type c) {
+        _buf.emplace_back(c);
+        return c;
+    }
+
+    virtual int_type uflow() {
+        return (_pos < _buf.size()) ? _buf[_pos++] : EOF;
+    }
+
+private:
+    std::vector<int_type> _buf;
+    size_t _pos;
+};
 // inline void print_bin_blob(cldnn::memory& mem, std::string name)
 // {
 //     auto&& size = mem.get_layout().get_tensor();
diff --git a/src/plugins/intel_gpu/thirdparty/CMakeLists.txt b/src/plugins/intel_gpu/thirdparty/CMakeLists.txt
index 5ad0f7f14cbb13..25ea5f74f52c5b 100644
--- a/src/plugins/intel_gpu/thirdparty/CMakeLists.txt
+++ b/src/plugins/intel_gpu/thirdparty/CMakeLists.txt
@@ -20,7 +20,7 @@ if(ENABLE_ONEDNN_FOR_GPU)
         set(ONEDNN_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/onednn_gpu_build/")
         set(ONEDNN_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/onednn_gpu_install/")
         set(ONEDNN_PREFIX_DIR "${CMAKE_CURRENT_BINARY_DIR}/onednn_gpu_root")
-        execute_process(COMMAND git apply --verbose ../onednn_gpu.patch
+        execute_process(COMMAND git apply ../onednn_gpu.patch OUTPUT_QUIET ERROR_QUIET
             WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/onednn_gpu")
         if(CMAKE_COMPILER_IS_GNUCXX)
             ie_add_compiler_flags(-Wno-undef -Wno-missing-declarations)