diff --git a/src/plugins/intel_gpu/include/intel_gpu/runtime/layout.hpp b/src/plugins/intel_gpu/include/intel_gpu/runtime/layout.hpp
index 2317c550826cd1..84f559799343c2 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/runtime/layout.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/runtime/layout.hpp
@@ -68,6 +68,7 @@ class optional_data_type {
     storage_type storage;
 };
 
+
 /// Converts C++ type to @ref data_types .
 template <typename T>
 struct type_to_data_type;
@@ -429,6 +430,38 @@ struct layout {
     tensor size;
 };
 
+class optional_layout {
+public:
+    optional_layout() {}
+    optional_layout(const layout& lay) {
+        this->opt_layout_ptr = make_unique<layout>(lay);
+    }
+
+    optional_layout(const optional_layout& new_opt_lay) {
+        if (new_opt_lay) {
+            layout copied_lay = *new_opt_lay;
+            this->opt_layout_ptr = make_unique<layout>(copied_lay);
+        }
+    }
+
+    operator bool() const {
+        return this->opt_layout_ptr != nullptr;
+    }
+
+    layout operator*() const {
+        if (opt_layout_ptr == nullptr)
+            throw std::runtime_error("Attempt to access uninitialized optional layout!");
+        return *this->opt_layout_ptr;
+    }
+
+    std::unique_ptr<layout>& get_layout_ptr() {
+        return opt_layout_ptr;
+    }
+
+private:
+    std::unique_ptr<layout> opt_layout_ptr = nullptr;
+};
+
 /// @}
 /// @}
 }  // namespace cldnn
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/add_onednn_optimization_attributes.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/add_onednn_optimization_attributes.cpp
index 1dfc07822f135e..9c4b6ce82f61e7 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/add_onednn_optimization_attributes.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/add_onednn_optimization_attributes.cpp
@@ -25,8 +25,7 @@ void add_onednn_optimization_attributes::run(program& p) {
                 // Reshape fused ops tensors for OneDNN FC if needed
                 if (fc_prim->input_size == 3) {
                     for (auto& fused_prim : node->get_fused_primitives()) {
-                        auto fused_node = fused_prim.node;
-                        if (fused_node->is_type<eltwise>()) {
+                        if (fused_prim.is_type<eltwise>()) {
                             auto& dependency = node->get_dependency(fused_prim.dep_start_idx);
                             auto original_layout = dependency.get_output_layout();
                             onednn::combine_bf_with_first_spatial_dim(original_layout);
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/basic_memory_dependencies.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/basic_memory_dependencies.cpp
index 526a5828b5195f..4d1024c227f70b 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/basic_memory_dependencies.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/basic_memory_dependencies.cpp
@@ -41,7 +41,7 @@ void basic_memory_dependencies::run(program& p) {
             && (node->is_type<convolution>() || node->is_type<deconvolution>())) {
             size_t eltw_dep = 0;
             for (auto& fused_op : node->get_fused_primitives()) {
-                if (fused_op.node->is_type<eltwise>() && fused_op.deps.size() == 1) {
+                if (fused_op.is_type<eltwise>() && fused_op.deps.size() == 1) {
                     // If it is first sum, reuse the buffer
                     auto fusing_type = onednn_add_fusing_helpers::get_add_fusing_type(*node, fused_op);
                     if (fusing_type != add_fusing_type::sum || eltw_dep != 0)
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_primitive_fusing.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_primitive_fusing.cpp
index f5389a48e2b150..6cf9ea167d67d7 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_primitive_fusing.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_primitive_fusing.cpp
@@ -674,10 +674,10 @@ void prepare_primitive_fusing::fuse_simple_primitives(program &p) {
                             auto& fused_descs = input_data.get_fused_primitives();
                             auto origin_input_iter = std::find_if(fused_descs.begin(), fused_descs.end(),
                                                                     [&](cldnn::fused_primitive_desc& desc) {
-                                return (desc.node->id() == prim_id.first);
+                                return (desc.desc->id == prim_id.first);
                             });
                             if (origin_input_iter != fused_descs.end()) {
-                                auto users = get_users_from_fusing_history(origin_input_iter->node->id());
+                                auto users = get_users_from_fusing_history(origin_input_iter->desc->id);
                                 if (users.size() != 1) {
                                     return false;
                                 }
@@ -1167,10 +1167,10 @@ void prepare_primitive_fusing::optimize_fused_ops(program& p) {
 
         auto remove_deps_of_node = [&](cldnn::fused_primitive_desc& desc) {
             for (auto& prim : fused_prims) {
-                if (desc.node->id() == prim.node->id()) {
+                if (desc.desc->id == prim.desc->id) {
                     continue;
                 }
-                auto rm_iter = prim.fused_deps.find(desc.node->id());
+                auto rm_iter = prim.fused_deps.find(desc.desc->id);
                 if (rm_iter != prim.fused_deps.end()) {
                     prim.fused_deps.erase(rm_iter);
                     prim.fused_deps.insert(desc.fused_deps.begin(), desc.fused_deps.end());
@@ -1187,16 +1187,13 @@ void prepare_primitive_fusing::optimize_fused_ops(program& p) {
 
             auto& fp = *curr_itr;
             auto& fp_next = *fp_itr;
+            if (fp.is_type<activation>() && fp_next.is_type<quantize>()) {
+                const auto& act_prim = fp.typed_desc<activation>();;
+                const auto& quant_param = fp_next.get_typed_fuse_params<kernel_selector::quantize_fuse_params>();
 
-            if (fp.node->is_type<activation>() && fp_next.node->is_type<quantize>()) {
-                auto& activation_node = fp.node->as<activation>();
-                auto& quantize_node = fp_next.node->as<quantize>();
-                bool can_skip = activation_node.get_primitive()->activation_function == activation_func::relu &&
-                                activation_node.get_primitive()->additional_params.a == 0.0f &&
-                                fp.deps.empty() &&
-                                data_type_traits::is_i8_u8(quantize_node.get_output_layout().data_type) &&
-                                quantize_node.get_scale_shift_opt() &&
-                                !quantize_node.get_need_pre_shift();
+                bool can_skip = fp.deps.empty() && data_type_traits::is_i8_u8(fp_next.output_layout.data_type);
+                can_skip &= ((act_prim->activation_function == activation_func::relu) && (act_prim->additional_params.a == 0.0f));
+                can_skip &= (quant_param->scale_shift_opt && !quant_param->has_pre_shift);
 
                 if (can_skip) {
                     remove_deps_of_node(fp);
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/remove_redundant_reorders.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/remove_redundant_reorders.cpp
index f77a9a1e08d0d3..7191cd2f88d7e2 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/remove_redundant_reorders.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/remove_redundant_reorders.cpp
@@ -485,14 +485,14 @@ void remove_redundant_reorders::run(program& p) {
             input.set_output_padding(node->get_output_layout().data_padding);
 
             // Add fused_primitive_desc of reorder to convolution which propagate original output layout to jitter
-            fused_primitive_desc local_desc;
-            local_desc.node = p.get_node_ptr(node->id());
+            fused_primitive_desc local_desc(node->get_primitive());
+            local_desc.input_layout = input.get_dependency(0).get_output_layout();  // original convolution's output layout
+            node->set_input_layout(local_desc.input_layout);
+            local_desc.f_param = node->get_fuse_params();
             local_desc.dep_start_idx = input.get_fused_primitives().size();
             local_desc.output_layout = output_layout;
-            local_desc.input_layout = input.get_dependency(0).get_output_layout();  // original convolution's output layout
             local_desc.activation = activation_func::none;
             input.add_fused_primitive(local_desc);
-            node->set_input_layout(local_desc.input_layout);
 
             // remove reorder node
             LOG_NODE_REMOVAL(node->id());
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp
index f7c91977e13088..d3c47ca6f67f45 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp
@@ -695,7 +695,7 @@ void reorder_inputs::run(program& p, layout_optimizer& lo, reorder_factory& rf)
         // changes the input format of eltwise sum post-op to use binary add.
         if (conv_node.get_preferred_impl_type() == impl_types::onednn) {
             onednn_add_fusing_helpers::for_eltwise(conv_node, eltwise_mode::sum,
-                [&](const program_node& p_node, const eltwise_node& e_node, const fused_primitive_desc& desc) {
+                [&](const program_node& p_node, const fused_primitive_desc& desc) {
                     auto fusing_type = onednn_add_fusing_helpers::get_add_fusing_type(p_node, desc);
                     if (fusing_type == add_fusing_type::binary_per_tensor) {
                         auto& dep_node = p_node.get_dependency(desc.dep_start_idx);
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 cd30eefe655251..92cedf20e6e308 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/condition.cpp
@@ -41,7 +41,7 @@ struct condition_impl : typed_primitive_impl<condition> {
         return ev;
     }
 
-    static primitive_impl* create(const condition_node& arg) { return new condition_impl(arg); }
+    static primitive_impl* create(const condition_node& arg, std::shared_ptr<kernel_impl_params>) { return new condition_impl(arg); }
 
     void init_kernels() override {}
 
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 0a8f05cacb3b9b..a9f6b36f4c081d 100644
--- a/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/common/loop.cpp
@@ -164,7 +164,7 @@ struct loop_impl : typed_primitive_impl<loop> {
         return ev;
     }
 
-    static primitive_impl* create(const loop_node& arg) { return new loop_impl(arg); }
+    static primitive_impl* create(const loop_node& arg, std::shared_ptr<kernel_impl_params>) { return new loop_impl(arg); }
 };
 
 namespace detail {
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 7f77619f7f2444..6a85557bce5f1e 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
@@ -32,13 +32,13 @@ class wait_for_events_impl : public primitive_impl {
 
     bool validate(const primitive_inst&) const override { return true; }
 
-    static primitive_impl* create_data(const data_node& data) { return new wait_for_events_impl(data); }
+    static primitive_impl* create_data(const data_node& data, std::shared_ptr<kernel_impl_params>) { return new wait_for_events_impl(data); }
 
-    static primitive_impl* create_input_layout(const input_layout_node& input) {
+    static primitive_impl* create_input_layout(const input_layout_node& input, std::shared_ptr<kernel_impl_params>) {
         return new wait_for_events_impl(input);
     }
 
-    static primitive_impl* create_prior_box(const prior_box_node& prior_box) {
+    static primitive_impl* create_prior_box(const prior_box_node& prior_box, std::shared_ptr<kernel_impl_params>) {
         // This primitive is being executed on CPU during network compilation.
         return new wait_for_events_impl(prior_box);
     }
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 031ff30cf725ac..3d18e359285a91 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/assign.cpp
@@ -38,7 +38,9 @@ struct assign_impl : public typed_primitive_impl<assign> {
     void init_kernels() override {}
 
 public:
-    static primitive_impl* create(assign_node const& arg) { return new assign_impl{}; }
+    static primitive_impl* create(const assign_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        return new 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 377ef6368faed3..c0fd99697e5907 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
@@ -833,7 +833,7 @@ struct detection_output_impl : typed_primitive_impl<detection_output> {
 
     void init_kernels() override {}
 
-    static primitive_impl* create(const detection_output_node& arg) { return new detection_output_impl(arg); }
+    static primitive_impl* create(const detection_output_node& arg, std::shared_ptr<kernel_impl_params>) { return new detection_output_impl(arg); }
 };
 
 namespace detail {
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 6b41ef35f68e5b..6aeecee9016eb5 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
@@ -401,7 +401,7 @@ struct non_max_suppression_impl : typed_primitive_impl<non_max_suppression> {
         return ev;
     }
 
-    static primitive_impl* create(const non_max_suppression_node&) {
+    static primitive_impl* create(const non_max_suppression_node&, std::shared_ptr<kernel_impl_params>) {
         return new non_max_suppression_impl();
     }
     void init_kernels() override {}
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 984a8577cab75a..0d81194cd7e9ae 100644
--- a/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
@@ -427,8 +427,8 @@ struct proposal_impl : typed_primitive_impl<proposal> {
 
     void init_kernels() override {}
 
-    static primitive_impl* create(const proposal_node& arg) {
-        const layout& l = arg.image_info().get_output_layout();
+    static primitive_impl* create(const proposal_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const layout& l = impl_param->input_layouts[2];
         const size_t count = l.feature() == 1 ? static_cast<size_t>(l.batch()) : static_cast<size_t>(l.feature());
 
         // Supported image_info sizes and components meaning:
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 6fa28707ed3867..a213906dc970a0 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
@@ -39,7 +39,9 @@ struct read_value_impl : public typed_primitive_impl<read_value> {
     void init_kernels() override {}
 
 public:
-    static primitive_impl* create(read_value_node const& arg) { return new read_value_impl{}; }
+    static primitive_impl* create(const read_value_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        return new read_value_impl{};
+    }
 };
 
 namespace detail {
diff --git a/src/plugins/intel_gpu/src/graph/impls/implementation_map.hpp b/src/plugins/intel_gpu/src/graph/impls/implementation_map.hpp
index ed008ef7a31400..5e1b135f824657 100644
--- a/src/plugins/intel_gpu/src/graph/impls/implementation_map.hpp
+++ b/src/plugins/intel_gpu/src/graph/impls/implementation_map.hpp
@@ -11,6 +11,8 @@
 #include <string>
 #include <sstream>
 #include "to_string_utils.h"
+#include "kernel_selector_helper.h"
+#include "activation_inst.h"
 
 namespace cldnn {
 
@@ -145,42 +147,39 @@ class implementation_map {
 public:
     using key_builder = implementation_key<primitive_kind>;
     using key_type = typename key_builder::type;
-    using factory_type = std::function<primitive_impl*(const typed_program_node<primitive_kind>&)>;
+    using factory_type = std::function<primitive_impl*(const typed_program_node<primitive_kind>&, std::shared_ptr<kernel_impl_params>)>;
     using map_type = singleton_map<impl_types, std::pair<std::set<key_type>, factory_type>>;
 
-    static factory_type get(const typed_program_node<primitive_kind>& primitive) {
-        impl_types target_impl_type = primitive.get_preferred_impl_type();
-        // lookup in database; throw if not found
-        auto key = key_builder()(primitive);
+    static factory_type get(std::shared_ptr<kernel_impl_params> impl_param, impl_types preferred_impl_type) {
+        auto key = key_builder()(impl_param->input_layouts[0]);
         for (auto& kv : map_type::instance()) {
             impl_types impl_type = kv.first;
-            if ((target_impl_type & impl_type) != impl_type)
+            if ((preferred_impl_type & impl_type) != impl_type)
                 continue;
-
             std::set<key_type>& keys_set = kv.second.first;
             auto& factory = kv.second.second;
-            if (keys_set.empty() || keys_set.find(key) != keys_set.end()) {
+            if (keys_set.empty() || keys_set.find(key) != keys_set.end())  {
                 return factory;
             }
         }
         std::stringstream target_impl_type_ss;
-        target_impl_type_ss << target_impl_type;
+        target_impl_type_ss << preferred_impl_type;
         throw std::runtime_error(std::string("implementation_map for ") + typeid(primitive_kind).name() +
                                     " could not find any implementation to match key: " +
-                                    get_key_name(key) + ", impl_type: " + target_impl_type_ss.str() + ", node_id: " + primitive.id());
+                                    get_key_name(key) + ", impl_type: " + target_impl_type_ss.str() + ", node_id: " + impl_param->desc->id);
     }
 
     // check if for a given engine and type there exist an implementation
-    static bool check(const typed_program_node<primitive_kind>& primitive) {
+    static bool check(const typed_program_node<primitive_kind>& primitive, std::shared_ptr<kernel_impl_params> impl_params) {
         impl_types target_impl_type = primitive.get_preferred_impl_type();
-        auto key = key_builder()(primitive);
+        auto key = key_builder()(impl_params->input_layouts[0]);
         return check_key(target_impl_type, key);
     }
 
     // check if there exists a kernel implementation of a primitive with output set it primitive's output layout
-    static bool check_io_eq(const typed_program_node<primitive_kind>& primitive) {
+    static bool check_io_eq(const typed_program_node<primitive_kind>& primitive, std::shared_ptr<kernel_impl_params> impl_params) {
         impl_types target_impl_type = primitive.get_preferred_impl_type();
-        auto key = key_builder()(primitive.get_output_layout());
+        auto key = key_builder()(impl_params->output_layout);
         return check_key(target_impl_type, key);
     }
 
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 d7fb9da8b76c11..4508a771e35cfe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/activation.cpp
@@ -30,17 +30,17 @@ struct activation_impl : typed_primitive_impl_ocl<activation> {
 
         return args;
     }
-
-    static primitive_impl* create(const activation_node& arg) {
-        auto activation_params = get_default_params<kernel_selector::activation_params>(arg);
+    static primitive_impl* create(const activation_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto activation_params = get_default_params<kernel_selector::activation_params>(*impl_param);
         auto activation_optional_params =
             get_default_optional_params<kernel_selector::activation_optional_params>(arg.get_program());
 
-        convert_new_activation_func(arg.get_primitive(), activation_params.activations);
+        convert_new_activation_func(prim, activation_params.activations);
 
         if (arg.is_parameterized()) {
-            const auto& slope_layout = arg.slope_input().get_output_layout();
-            const auto& output_layout = arg.get_output_layout();
+            const auto& slope_layout = impl_param->input_layouts[1];
+            const auto& output_layout = impl_param->output_layout;
 
             const auto params_num =
                 kernel_selector::GetActivationAdditionalParamsNumber(activation_params.activations[0].function);
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 84a9fde6f0fd50..35e06fb78c35fd 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
@@ -35,8 +35,8 @@ struct adaptive_pooling_impl : public typed_primitive_impl_ocl<adaptive_pooling>
     }
 
 public:
-    static primitive_impl* create(const adaptive_pooling_node& arg) {
-        auto params = get_default_params<kernel_selector::adaptive_pooling_params>(arg);
+    static primitive_impl* create(const adaptive_pooling_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::adaptive_pooling_params>(*impl_param);
         auto optional_params = get_default_optional_params<kernel_selector::adaptive_pooling_optional_params>(arg.get_program());
 
         const auto& primitive = arg.get_primitive();
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 1df36cf25c47be..641affe72ed2ec 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
@@ -34,9 +34,8 @@ struct arg_max_min_impl : typed_primitive_impl_ocl<arg_max_min> {
     }
 
 public:
-    static primitive_impl* create(const arg_max_min_node& arg) {
+    static primitive_impl* create(const arg_max_min_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
-
         const auto& axis = primitive->axis;
         const auto& top_k = primitive->top_k;
         const auto& out_type = primitive->output_type;
@@ -45,7 +44,7 @@ struct arg_max_min_impl : typed_primitive_impl_ocl<arg_max_min> {
         const auto& values_first = primitive->values_first;
         const auto& outputs_num = primitive->input.size() == 3 ? 2 : 1;  // second output passed as input for TOP_K layer
 
-        auto argm_params = get_default_params<kernel_selector::arg_max_min_params>(arg);
+        auto argm_params = get_default_params<kernel_selector::arg_max_min_params>(*impl_param);
         auto argm_optional_params =
             get_default_optional_params<kernel_selector::arg_max_min_optional_params>(arg.get_program());
 
@@ -84,7 +83,7 @@ struct arg_max_min_impl : typed_primitive_impl_ocl<arg_max_min> {
             argm_params.argMaxMinSortType = kernel_selector::argm_sort::INDEX;
 
         if (outputs_num == 2) {
-            argm_params.inputs.push_back(convert_data_tensor(arg.get_dependency(2).get_output_layout()));
+            argm_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
         }
 
         argm_params.values_first = values_first;
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 09d1beddb1d822..4d9787057f85e8 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
@@ -28,13 +28,13 @@ struct average_unpooling_impl : typed_primitive_impl_ocl<average_unpooling> {
     }
 
 public:
-    static primitive_impl* create(const average_unpooling_node& arg) {
-        auto average_unpooling_params = get_default_params<kernel_selector::average_unpooling_params>(arg);
+    static primitive_impl* create(const average_unpooling_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto primitive = arg.get_primitive();
+        auto average_unpooling_params = get_default_params<kernel_selector::average_unpooling_params>(*impl_param);
         auto average_unpooling_optional_params =
             get_default_optional_params<kernel_selector::average_unpooling_optional_params>(arg.get_program());
         auto& params = average_unpooling_params;
 
-        auto primitive = arg.get_primitive();
         auto stride = primitive->stride;
 
         params.unpoolSize = {
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 52dba85e6a7ef7..3b086d0593bba2 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
@@ -25,13 +25,12 @@ struct batch_to_space_impl : typed_primitive_impl_ocl<batch_to_space> {
     }
 
 public:
-    static primitive_impl* create(const batch_to_space_node& arg) {
-        auto batch_to_space_params = get_default_params<kernel_selector::batch_to_space_params>(arg);
+    static primitive_impl* create(const batch_to_space_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto primitive = arg.get_primitive();
+        auto batch_to_space_params = get_default_params<kernel_selector::batch_to_space_params>(*impl_param);
         auto batch_to_space_optional_params =
             get_default_optional_params<kernel_selector::batch_to_space_optional_params>(arg.get_program());
 
-        auto primitive = arg.get_primitive();
-
         batch_to_space_params.block_shape = convert_dim_vector(primitive->block_shape);
         batch_to_space_params.crops_begin = convert_dim_vector(primitive->crops_begin);
         batch_to_space_params.crops_end = convert_dim_vector(primitive->crops_end);
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 8fbbc1ee9f14ae..f0b290841b8eb5 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
@@ -60,9 +60,9 @@ struct binary_convolution_impl : typed_primitive_impl_ocl<binary_convolution> {
     int32_t get_split() const override { return _outer.get_split(); }
 
 public:
-    static primitive_impl* create(const binary_convolution_node& arg) {
+    static primitive_impl* create(const binary_convolution_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
-        const auto& weights_layout = arg.weights(0).get_output_layout().convert_to_weights_layout(false);
+        const auto& weights_layout = (*impl_param->weights_layout).convert_to_weights_layout(false);
         const auto& weights_size = weights_layout.get_tensor();
 
         const auto& split = primitive->split();
@@ -74,12 +74,10 @@ struct binary_convolution_impl : typed_primitive_impl_ocl<binary_convolution> {
         const auto depthwise_separable_opt = arg.get_depthwise_sep_opt();
         const auto actual_split = depthwise_separable_opt ? (decltype(split))1 : split;
 
-        assert(arg.get_output_layout().feature() / primitive->split() == weights_layout.batch());
+        assert(impl_param->output_layout.feature() / primitive->split() == weights_layout.batch());
 
-        auto conv_params =
-            get_weights_bias_default_params<kernel_selector::binary_convolution_params>(arg, actual_split);
-        auto conv_optional_params =
-            get_default_weights_bias_optional_params<kernel_selector::binary_convolution_optional_params>(
+        auto conv_params = get_weights_bias_default_params<kernel_selector::binary_convolution_params>(*impl_param, actual_split);
+        auto conv_optional_params = get_default_weights_bias_optional_params<kernel_selector::binary_convolution_optional_params>(
                 arg.get_program());
 
         conv_params.pad_value = primitive->pad_value;
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 702005b54471b4..b3ee4358dbeb34 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
@@ -22,13 +22,13 @@ struct border_impl : typed_primitive_impl_ocl<border> {
         return make_unique<border_impl>(*this);
     }
 
-    static primitive_impl* create(const border_node& arg) {
-        auto b_params = get_default_params<kernel_selector::border_params>(arg, 1);
+    static primitive_impl* create(const border_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto desc = arg.get_primitive();
+
+        auto b_params = get_default_params<kernel_selector::border_params>(*impl_param, 1);
         auto b_optional_params =
             get_default_optional_params<kernel_selector::border_optional_params>(arg.get_program());
 
-        auto desc = arg.get_primitive();
-
         b_params.lt_sizes = convert_dim_vector(desc->left_top_sizes);
         b_params.rb_sizes = convert_dim_vector(desc->right_bottom_sizes);
         b_params.border_value = desc->border_value;
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 240c5a276aae2c..9961c5a81a8dea 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/broadcast.cpp
@@ -22,15 +22,16 @@ struct broadcast_impl : typed_primitive_impl_ocl<broadcast> {
         return make_unique<broadcast_impl>(*this);
     }
 
-    static primitive_impl* create(const broadcast_node& arg) {
-        auto bc_params = get_default_params<kernel_selector::broadcast_params>(arg, 1);
+    static primitive_impl* create(const broadcast_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto bc_params = get_default_params<kernel_selector::broadcast_params>(*impl_param, 1);
         auto bc_optional_params =
             get_default_optional_params<kernel_selector::broadcast_optional_params>(arg.get_program());
 
-        const auto format = arg.get_output_layout().format;
+        const auto format = impl_param->output_layout.format;
         size_t max_axes_num = format.dimension();
 
-        const auto& broadcast_axes = arg.get_primitive()->broadcast_axes;
+        const auto& broadcast_axes = primitive->broadcast_axes;
         uint16_t index = (uint16_t)0;
         uint16_t input_index = (uint16_t)broadcast_axes.size();
 
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 ddf972fd77b182..8e49e7e9c2fd15 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/bucketize.cpp
@@ -24,8 +24,8 @@ struct bucketize_impl : typed_primitive_impl_ocl<bucketize> {
         return make_unique<bucketize_impl>(*this);
     }
 
-    static primitive_impl* create(const bucketize_node& arg) {
-        auto params = get_default_params<kernel_selector::bucketize_params>(arg);
+    static primitive_impl* create(const bucketize_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::bucketize_params>(*impl_param);
         auto optional_params =
             get_default_optional_params<kernel_selector::bucketize_optional_params>(arg.get_program());
 
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 e0e22e31762cab..645ee08f1830ab 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
@@ -69,23 +69,22 @@ struct concatenation_impl : typed_primitive_impl_ocl<concatenation> {
     }
 
 public:
-    static primitive_impl* create(const concatenation_node& arg) {
+    static primitive_impl* create(const concatenation_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         if (arg.can_be_optimized()) {
             return new concatenation_impl(arg, {});
         }
-
-        auto concat_params = get_default_params<kernel_selector::concatenation_params>(arg);
-        auto concat_optional_params =
-            get_default_optional_params<kernel_selector::concatenation_optional_params>(arg.get_program());
-        auto axis = arg.get_primitive()->axis;
+        const auto& primitive = arg.get_primitive();
+        auto concat_params = get_default_params<kernel_selector::concatenation_params>(*impl_param);
+        auto concat_optional_params = get_default_optional_params<kernel_selector::concatenation_optional_params>(arg.get_program());
+        auto axis = primitive->axis;
 
         concat_params.inputs.resize(arg.inputs_count());
         for (size_t i = 0; i < arg.inputs_count(); ++i) {
-            const layout& input_layout = arg.input(i).get_output_layout();
+            const layout& input_layout = impl_param->input_layouts[i];
             concat_params.inputs[i] = convert_data_tensor(input_layout);
         }
 
-        concat_params.axis = convert_axis(axis, arg.get_output_layout().get_rank());
+        concat_params.axis = convert_axis(axis, impl_param->output_layout.get_rank());
         concat_optional_params.kernelPerInput = true;
 
         auto& kernel_selector = kernel_selector::concatenation_kernel_selector::Instance();
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 a8c1920afe7dc6..133c8ec9654326 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
@@ -31,17 +31,17 @@ struct convert_color_impl : typed_primitive_impl_ocl<convert_color> {
     }
 
 public:
-    static primitive_impl* create(const convert_color_node& arg) {
-        auto convert_color_params = get_default_params<kernel_selector::convert_color_params>(arg);
+    static primitive_impl* create(const convert_color_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto primitive = arg.get_primitive();
+
+        auto convert_color_params = get_default_params<kernel_selector::convert_color_params>(*impl_param);
         auto convert_color_optional_params =
             get_default_optional_params<kernel_selector::convert_color_optional_params>(arg.get_program());
 
-        for (size_t i = 1; i < arg.inputs_count(); ++i) {
-            convert_color_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+        for (size_t i = 1; i < impl_param->input_layouts.size(); ++i) {
+            convert_color_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
-        auto primitive = arg.get_primitive();
-
         convert_color_params.input_color_format = static_cast<kernel_selector::color_format>(primitive->input_color_format);
         convert_color_params.output_color_format = static_cast<kernel_selector::color_format>(primitive->output_color_format);
         convert_color_params.mem_type = static_cast<kernel_selector::memory_type>(primitive->mem_type);
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 41f8295c0a357d..9fc27bc70049fc 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/convolution.cpp
@@ -60,9 +60,8 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
     bool get_depthwise_sep_opt() const override { return _outer.get_depthwise_sep_opt(); }
 
 public:
-    static primitive_impl* create(const convolution_node& arg) {
+    static primitive_impl* create(const convolution_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
-        const auto& weights_layout = arg.weights(0).get_output_layout().convert_to_weights_layout(primitive->grouped_weights_shape);
 
         const auto &split = primitive->split();
         auto stride = primitive->stride;
@@ -73,15 +72,15 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
         const auto transposed = arg.get_transposed();
 
         auto conv_params = get_weight_bias_zero_point_default_params<kernel_selector::convolution_params>(
-            arg, split, 1, primitive->grouped_weights_shape);
+            *impl_param, split, 1, primitive->grouped_weights_shape);
         auto conv_optional_params =
             get_default_weights_bias_optional_params<kernel_selector::convolution_optional_params>(arg.get_program());
 
         if (primitive->deformable_mode) {
-            conv_params.inputs.push_back(convert_data_tensor(arg.trans().get_output_layout()));
+            conv_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
             conv_params.deformable_mode = true;
             if (primitive->input.size() == 3) {
-                conv_params.inputs.push_back(convert_data_tensor(arg.mask().get_output_layout()));
+                conv_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
                 conv_params.deformable_mask_enabled = true;
             }
             conv_params.bilinear_interpolation_pad = arg.bilinear_interpolation_pad();
@@ -93,6 +92,8 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
         conv_params.split = split;
         conv_params.groups = groups;
 
+        const auto& weights_layout = impl_param->input_layouts[1 + 0 + arg.get_deform_conv_dep_offset()]
+                                                                .convert_to_weights_layout(primitive->grouped_weights_shape);
         uint32_t kx = weights_layout.spatial(0);
         uint32_t ky = weights_layout.spatial(1);
         uint32_t kz = weights_layout.spatial(2);
@@ -113,9 +114,9 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
         uint32_t dilation_x = dilation.size() >= 1 ? dilation[dilation.size() - 1] : 1;
         conv_params.dilation = {dilation_x, dilation_y, dilation_z};
 
-        if ((arg.get_dependency(0).get_output_layout().data_type == data_types::u8 ||
-             arg.get_dependency(0).get_output_layout().data_type == data_types::i8) &&
-            arg.get_dependency(1).get_output_layout().data_type == data_types::i8) {
+        if ((impl_param->input_layouts[0].data_type == data_types::u8 ||
+             impl_param->input_layouts[0].data_type == data_types::i8) &&
+             impl_param->input_layouts[1].data_type == data_types::i8) {
             if (!primitive->weights_zero_points.empty() && !primitive->activations_zero_points.empty()) {
                 conv_params.quantization = kernel_selector::QuantizationType::ASYMMETRIC_DATA_AND_WEIGHTS;
             } else if (!primitive->weights_zero_points.empty()) {
@@ -129,7 +130,7 @@ struct convolution_impl : typed_primitive_impl_ocl<convolution> {
             conv_params.quantization = kernel_selector::QuantizationType::NONE;
         }
 
-        auto format = arg.get_output_layout().format;
+        auto format = impl_param->output_layout.format;
         if (format == format::b_fs_zyx_fsv16 ||
             format == format::bs_fs_zyx_bsv16_fsv16 ||
             format == format::bs_fs_yx_bsv16_fsv16 ||
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 5136a426814213..deb8fb573142c1 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/crop.cpp
@@ -27,16 +27,17 @@ struct crop_impl : typed_primitive_impl_ocl<crop> {
     }
 
 public:
-    static primitive_impl* create(const crop_node& arg) {
-        auto ew_params = get_default_params<kernel_selector::eltwise_params>(arg, 1);
-        auto ew_optional_params =
-            get_default_optional_params<kernel_selector::eltwise_optional_params>(arg.get_program());
+    static primitive_impl* create(const crop_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+
+        auto ew_params = get_default_params<kernel_selector::eltwise_params>(*impl_param, 1);
+        auto ew_optional_params = get_default_optional_params<kernel_selector::eltwise_optional_params>(arg.get_program());
 
         ew_params.operations.push_back(
             {{kernel_selector::eltwise_params::InputType::Buffer(0)}, kernel_selector::eltwise_mode::ASSIGN});
 
-        const auto& input_layout = arg.input().get_output_layout();
-        ew_params.inputs[0] = convert_data_tensor(input_layout, 1, arg.get_primitive()->offsets);
+        const auto& input_layout = impl_param->input_layouts[0];
+        ew_params.inputs[0] = convert_data_tensor(input_layout, 1, primitive->offsets);
 
         auto& kernel_selector = kernel_selector::eltwise_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(ew_params, ew_optional_params);
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 89eaa6672a3a67..3fbd097019faf6 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
@@ -26,20 +26,20 @@ struct ctc_greedy_decoder_impl : typed_primitive_impl_ocl<ctc_greedy_decoder> {
     }
 
 public:
-    static primitive_impl* create(const ctc_greedy_decoder_node& arg) {
-        auto ctc_gd_params = get_default_params<kernel_selector::ctc_greedy_decoder_params>(arg);
-        auto ctc_gd_optional_params = get_default_optional_params<kernel_selector::ctc_greedy_decoder_optional_params>(arg.get_program());
+    static primitive_impl* create(const ctc_greedy_decoder_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         auto prim = arg.get_primitive();
 
-        ctc_gd_params.inputs.push_back(
-            convert_data_tensor(arg.seq_indicators().get_output_layout()));
+        auto ctc_gd_params = get_default_params<kernel_selector::ctc_greedy_decoder_params>(*impl_param);
+        auto ctc_gd_optional_params = get_default_optional_params<kernel_selector::ctc_greedy_decoder_optional_params>(arg.get_program());
+
+        ctc_gd_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
         ctc_gd_params.merge_repeated = prim->ctc_merge_repeated;
         ctc_gd_params.blank_index = prim->blank_index;
         ctc_gd_params.outputs_num = arg.has_second_output() ? 2 : 1;
 
         if (ctc_gd_params.outputs_num == 2) {
-            ctc_gd_params.inputs.push_back(
-                convert_data_tensor(arg.second_output().get_output_layout()));
+            const auto& second_output_layout = impl_param->input_layouts[1];
+            ctc_gd_params.inputs.push_back(convert_data_tensor(second_output_layout));
         }
 
         auto& kernel_selector = kernel_selector::ctc_greedy_decoder_kernel_selector::Instance();
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 3a6b08e365f1fd..fa855a3f1c2d27 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
@@ -45,12 +45,14 @@ struct cum_sum_impl : typed_primitive_impl_ocl<cum_sum> {
     }
 
 public:
-    static primitive_impl* create(const cum_sum_node& arg) {
-        auto cum_sum_params = get_default_params<kernel_selector::cum_sum_params>(arg);
+    static primitive_impl* create(const cum_sum_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+
+        auto cum_sum_params = get_default_params<kernel_selector::cum_sum_params>(*impl_param);
         auto cum_sum_optional_params =
             get_default_optional_params<kernel_selector::cum_sum_optional_params>(arg.get_program());
 
-        cum_sum_params.axis = convert_axis(arg.get_primitive()->axis);
+        cum_sum_params.axis = convert_axis(prim->axis);
         cum_sum_params.exclusive = arg.get_primitive()->exclusive;
         cum_sum_params.reverse = arg.get_primitive()->reverse;
 
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 87e922ca9560b5..1c843bbc508117 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
@@ -179,7 +179,7 @@ static void add_layout_to_jit(kernel_selector::jit_constants& mem_consts, const
     mem_consts.AddConstant(kernel_selector::MakeJitConstant(name + "_OFFSET", std::to_string(offset)));
 }
 
-static std::string get_jit_constant(const custom_gpu_primitive_node& outer) {
+static std::string get_jit_constant(const custom_gpu_primitive_node& outer, const kernel_impl_params& impl_param) {
     kernel_selector::jit_constants mem_consts{
         kernel_selector::MakeJitConstant("NUM_INPUTS", std::to_string(outer.get_dependencies().size()))};
     const auto primitive = outer.get_primitive().get();
@@ -189,11 +189,11 @@ static std::string get_jit_constant(const custom_gpu_primitive_node& outer) {
         kernel_selector::MakeJitConstant("LOCAL_WORKSIZE", primitive->lws),
     });
 
-    for (size_t i = 0; i < outer.get_dependencies().size(); i++) {
-        add_layout_to_jit(mem_consts, "INPUT" + std::to_string(i), outer.input(i).get_output_layout());
+    for (size_t i = 0; i < impl_param.input_layouts.size(); i++) {
+        add_layout_to_jit(mem_consts, "INPUT" + std::to_string(i), impl_param.input_layouts[i]);
     }
 
-    add_layout_to_jit(mem_consts, "OUTPUT0", outer.get_output_layout());
+    add_layout_to_jit(mem_consts, "OUTPUT0", impl_param.output_layout);
 
     std::ostringstream oss;
     oss << "// Custom Layer Built-ins\n\n";
@@ -204,14 +204,14 @@ static std::string get_jit_constant(const custom_gpu_primitive_node& outer) {
     return oss.str();
 }
 
-static primitive_impl* create(const custom_gpu_primitive_node& arg) {
+static primitive_impl* create(const custom_gpu_primitive_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
     const auto primitive = arg.get_primitive().get();
 
     auto cl_kernel = std::make_shared<kernel_selector::cl_kernel_data>();
     cl_kernel->code.kernelString = std::make_shared<kernel_selector::kernel_string>();
     cl_kernel->code.kernelString->entry_point = primitive->kernel_entry_point;
     cl_kernel->code.kernelString->options = primitive->build_options;
-    cl_kernel->code.kernelString->jit = get_jit_constant(arg);
+    cl_kernel->code.kernelString->jit = get_jit_constant(arg, *impl_param);
     for (const auto& s : primitive->kernels_code) {
         cl_kernel->code.kernelString->str += s + "\n";
     }
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 133a3f876d956a..189d098553afdd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/deconvolution.cpp
@@ -51,24 +51,18 @@ struct deconvolution_impl : typed_primitive_impl_ocl<deconvolution> {
     uint32_t get_groups() const override { return _outer.get_groups(); }
 
 public:
-    static primitive_impl* create(const deconvolution_node& arg) {
+    static primitive_impl* create(const deconvolution_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
-        const auto& weights_layout = arg.weights(0).get_output_layout().convert_to_weights_layout(primitive->grouped_weights_shape);
-
         const auto& split = primitive->split();
         const auto& stride = primitive->stride;
-#if 0  // TODO: support dilation
-        const auto& dilation = primitive->dilation;
-#else
-        const ov::Strides dilation(arg.get_output_layout().get_spatial_rank(), 1);
-#endif
+        const ov::Strides dilation(impl_param->output_layout.get_spatial_rank(), 1);
         const auto actual_split = split;
 
         const auto& pad = primitive->pad;
         const auto& groups = primitive->groups;
 
         auto deconv_params = get_weights_bias_default_params<kernel_selector::deconvolution_params>(
-            arg,
+            *impl_param,
             (groups > 1) ? 1 : actual_split,
             1,
             primitive->grouped_weights_shape);
@@ -78,6 +72,8 @@ struct deconvolution_impl : typed_primitive_impl_ocl<deconvolution> {
         deconv_params.split = split;
         deconv_params.groups = groups;
 
+        const auto weights_idx = 1 + 0;
+        const auto& weights_layout = impl_param->input_layouts[weights_idx].convert_to_weights_layout(primitive->grouped_weights_shape);
         uint32_t kx = weights_layout.spatial(0);
         uint32_t ky = weights_layout.spatial(1);
         uint32_t kz = weights_layout.spatial(2);
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 afe76537b8b704..db0c7b05182e87 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
@@ -37,11 +37,8 @@ struct deformable_conv_impl : typed_primitive_impl_ocl<deformable_conv> {
     uint32_t get_groups() const override { return _outer.get_groups(); }
 
 public:
-    static primitive_impl* create(const deformable_conv_node& arg) {
+    static primitive_impl* create(const deformable_conv_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
-        const auto& weights_layout = arg.weights(0).get_output_layout().convert_to_weights_layout(false);
-        const auto& weights_size = weights_layout.get_tensor();
-
         const auto& split = primitive->split();
         const auto& groups = primitive->groups;
 
@@ -49,12 +46,16 @@ struct deformable_conv_impl : typed_primitive_impl_ocl<deformable_conv> {
         const auto actual_split = depthwise_separable_opt ? (decltype(split))1 : split;
 
         auto conv_params = get_weights_bias_default_params<kernel_selector::convolution_params>(
-            arg,
+            *impl_param,
             (groups > 1 && !depthwise_separable_opt) ? groups : actual_split,
             groups);
         auto conv_optional_params =
             get_default_weights_bias_optional_params<kernel_selector::convolution_optional_params>(arg.get_program());
 
+        const auto weight_idx = 1 + 0;
+        const auto& weights_layout = impl_param->input_layouts[weight_idx].convert_to_weights_layout(false);
+        const auto& weights_size = weights_layout.get_tensor();
+
         conv_params.depthwise_separable_opt = depthwise_separable_opt;
         conv_params.split = split;
         conv_params.groups = groups;
@@ -91,9 +92,12 @@ struct deformable_interp_impl : typed_primitive_impl_ocl<deformable_interp> {
     uint32_t get_groups() const override { return 1; }
 
 public:
-    static primitive_impl* create(const deformable_interp_node& arg) {
+    static primitive_impl* create(const deformable_interp_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto input_idx = 0;
+        const auto trans_idx = 1;
+        const auto mask_idx = 2;
         const auto& primitive = arg.get_primitive();
-        const auto& input_layout = arg.input().get_output_layout();
+        const auto& input_layout = impl_param->input_layouts[input_idx];
         const auto& kernel_size = primitive->kernel_size;
 
         auto stride = primitive->stride;
@@ -102,7 +106,7 @@ struct deformable_interp_impl : typed_primitive_impl_ocl<deformable_interp> {
         const auto& groups = primitive->groups;
         const auto& deformable_groups = primitive->deformable_groups;
 
-        auto conv_params = get_default_params<kernel_selector::convolution_params>(arg, groups);
+        auto conv_params = get_default_params<kernel_selector::convolution_params>(*impl_param, groups);
         auto conv_optional_params =
             get_default_optional_params<kernel_selector::convolution_optional_params>(arg.get_program());
 
@@ -110,9 +114,9 @@ struct deformable_interp_impl : typed_primitive_impl_ocl<deformable_interp> {
         auto weights_layout = layout(input_layout.data_type, input_layout.format, kernel_size);
         conv_params.weights = convert_weights_tensor(weights_layout);
 
-        conv_params.inputs.push_back(convert_data_tensor(arg.trans().get_output_layout()));
+        conv_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[trans_idx]));
         if (primitive->input.size() == 3) {
-            conv_params.inputs.push_back(convert_data_tensor(arg.mask().get_output_layout()));
+            conv_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[mask_idx]));
             conv_params.deformable_mask_enabled = true;
         }
         conv_params.bilinear_interpolation_pad = primitive->bilinear_interpolation_pad;
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 4feb9df1f5f9c7..c86db2ac2842aa 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
@@ -24,13 +24,15 @@ struct depth_to_space_impl : typed_primitive_impl_ocl<depth_to_space> {
     }
 
 public:
-    static primitive_impl* create(const depth_to_space_node& arg) {
-        auto depth_to_space_params = get_default_params<kernel_selector::depth_to_space_params>(arg);
+    static primitive_impl* create(const depth_to_space_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+
+        auto depth_to_space_params = get_default_params<kernel_selector::depth_to_space_params>(*impl_param);
         auto depth_to_space_optional_params =
             get_default_optional_params<kernel_selector::depth_to_space_optional_params>(arg.get_program());
 
-        depth_to_space_params.block_size = arg.get_primitive()->block_size;
-        depth_to_space_params.mode = arg.get_primitive()->mode == depth_to_space_mode::blocks_first ? kernel_selector::depth_to_space_mode::BLOCKS_FIRST
+        depth_to_space_params.block_size = prim->block_size;
+        depth_to_space_params.mode = prim->mode == depth_to_space_mode::blocks_first ? kernel_selector::depth_to_space_mode::BLOCKS_FIRST
                                                                                                     : kernel_selector::depth_to_space_mode::DEPTH_FIRST;
 
         auto& kernel_selector = kernel_selector::depth_to_space_kernel_selector::Instance();
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 fad68beb69e506..ec14a098eeda9b 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
@@ -51,13 +51,15 @@ struct detection_output_impl : typed_primitive_impl_ocl<detection_output> {
     }
 
 public:
-    static primitive_impl* create(const detection_output_node& arg) {
-        auto detect_out_params = get_default_params<kernel_selector::detection_output_params>(arg);
+    static primitive_impl* create(const detection_output_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto detect_out_params = get_default_params<kernel_selector::detection_output_params>(*impl_param);
         auto detect_out_optional_params =
             get_default_optional_params<kernel_selector::detection_output_optional_params>(arg.get_program());
 
-        detect_out_params.inputs.push_back(convert_data_tensor(arg.confidence().get_output_layout()));
-        detect_out_params.inputs.push_back(convert_data_tensor(arg.prior_box().get_output_layout()));
+        const auto confidence_idx = 1;
+        const auto prior_box_idx = 2;
+        detect_out_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[confidence_idx]));
+        detect_out_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[prior_box_idx]));
         set_detection_output_specific_params(detect_out_params.detectOutParams, arg);
 
         auto& kernel_selector = kernel_selector::detection_output_kernel_selector::Instance();
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 ed3e69cbea1a90..9580155bc118c4 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/dft.cpp
@@ -22,8 +22,8 @@ struct dft_impl : typed_primitive_impl_ocl<dft> {
         return make_unique<dft_impl>(*this);
     }
 
-    static primitive_impl* create(const dft_node& arg) {
-        auto params = get_default_params<kernel_selector::dft_params>(arg);
+    static primitive_impl* create(const dft_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::dft_params>(*impl_param);
         auto primitive = arg.get_primitive();
         params.axes = primitive->axes;
         if (primitive->kind == dft_kind::inverse) {
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 b5f9033e0c5741..6892f26daa46dd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/eltwise.cpp
@@ -29,16 +29,17 @@ struct eltwise_impl : typed_primitive_impl_ocl<eltwise> {
     }
 
 public:
-    static primitive_impl* create(const eltwise_node& arg) {
-        auto ew_params = get_default_params<kernel_selector::eltwise_params>(arg);
+    static primitive_impl* create(const eltwise_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+
+        auto ew_params = get_default_params<kernel_selector::eltwise_params>(*impl_param);
         auto ew_optional_params =
             get_default_optional_params<kernel_selector::eltwise_optional_params>(arg.get_program());
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            ew_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            ew_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
-        const auto& primitive = arg.get_primitive();
 
         ew_params.operations.push_back({{kernel_selector::eltwise_params::InputType::Buffer(0),
                                          kernel_selector::eltwise_params::InputType::Buffer(1)},
@@ -56,8 +57,8 @@ struct eltwise_impl : typed_primitive_impl_ocl<eltwise> {
 
         for (size_t i = 0; i < ew_params.inputs.size(); i++) {
             if (!ew_params.inputs[i].SameDims(ew_params.outputs[0])) {
-                std::vector<int32_t> input_size = arg.input(i).get_output_layout().get_tensor().raw.vector();
-                std::vector<int32_t> output_size = arg.get_output_layout().get_tensor().raw.vector();
+                std::vector<int32_t> input_size = impl_param->input_layouts[i].get_tensor().raw.vector();
+                std::vector<int32_t> output_size = impl_param->output_layout.get_tensor().raw.vector();
                 bool broadcast = false;
                 for (size_t d = 0; d < output_size.size(); d++) {
                     if (output_size[d] != 1 && input_size[d] == 1)
@@ -98,8 +99,8 @@ struct eltwise_impl : typed_primitive_impl_ocl<eltwise> {
         // TODO [LOW PRECISION]: check if this parameter's really needed. Maybe data types are enough
         bool quantization = true;
         for (size_t i = 0; i < arg.inputs_count(); i++) {
-            if (arg.input(i).get_output_layout().data_type != data_types::u8 &&
-                arg.input(i).get_output_layout().data_type != data_types::i8) {
+            if (impl_param->input_layouts[i].data_type != data_types::u8 &&
+                impl_param->input_layouts[i].data_type != data_types::i8) {
                 quantization = false;
             }
         }
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 936c47ec639f6b..61a09629391c12 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
@@ -24,12 +24,13 @@ struct embedding_bag_impl : typed_primitive_impl_ocl<embedding_bag> {
     }
 
 public:
-    static primitive_impl* create(const embedding_bag_node& arg) {
-        auto embedding_bag_params = get_default_params<kernel_selector::embedding_bag_params>(arg);
+    static primitive_impl* create(const embedding_bag_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto embedding_bag_params = get_default_params<kernel_selector::embedding_bag_params>(*impl_param);
         auto embedding_bag_optional_params =
             get_default_optional_params<kernel_selector::embedding_bag_optional_params>(arg.get_program());
 
-        switch (arg.get_primitive()->type) {
+        switch (primitive->type) {
         case embedding_bag::packed_sum:
             embedding_bag_params.type = kernel_selector::EmbeddingBagType::PACKED_SUM;
             break;
@@ -45,7 +46,7 @@ struct embedding_bag_impl : typed_primitive_impl_ocl<embedding_bag> {
         }
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            embedding_bag_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            embedding_bag_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
         embedding_bag_params.default_index = arg.get_primitive()->default_index;
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 57d57b47ef3545..ac529fe4c30efe 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
@@ -31,8 +31,8 @@ struct experimental_detectron_detection_output_impl
     }
 
 public:
-    static primitive_impl* create(const experimental_detectron_detection_output_node& arg) {
-        auto params = get_default_params<kernel_selector::experimental_detectron_detection_output_params>(arg);
+    static primitive_impl* create(const experimental_detectron_detection_output_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::experimental_detectron_detection_output_params>(*impl_param);
         auto optional_params =
             get_default_optional_params<kernel_selector::experimental_detectron_detection_output_optional_params>(
                 arg.get_program());
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 3fa8265c34d174..430ca1149505d7 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
@@ -37,8 +37,8 @@ struct experimental_detectron_generate_proposals_single_image_impl
     }
 
 public:
-    static primitive_impl* create(const experimental_detectron_generate_proposals_single_image_node& arg) {
-        auto params = get_default_params<kernel_selector::experimental_detectron_generate_proposals_single_image_params>(arg);
+    static primitive_impl* create(const experimental_detectron_generate_proposals_single_image_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::experimental_detectron_generate_proposals_single_image_params>(*impl_param);
         auto optional_params = get_default_optional_params<
                 kernel_selector::experimental_detectron_generate_proposals_single_image_optional_params>(arg.get_program());
 
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 a0b3d373aa9835..73f15315b0fb7d 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
@@ -26,8 +26,8 @@ struct experimental_detectron_prior_grid_generator_impl
         return make_unique<experimental_detectron_prior_grid_generator_impl>(*this);
     }
 
-    static primitive_impl* create(const experimental_detectron_prior_grid_generator_node& arg) {
-        auto params = get_default_params<kernel_selector::experimental_detectron_prior_grid_generator_params>(arg);
+    static primitive_impl* create(const experimental_detectron_prior_grid_generator_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::experimental_detectron_prior_grid_generator_params>(*impl_param);
         auto primPtr = arg.get_primitive();
         auto& prim = *primPtr;
 
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 21b9a9c21dbea4..4ba3b50a89c107 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
@@ -39,8 +39,9 @@ struct experimental_detectron_roi_feature_extractor_impl : public typed_primitiv
     }
 
 public:
-    static primitive_impl* create(const experimental_detectron_roi_feature_extractor_node& arg) {
-        const auto output_layout = arg.get_output_layout();
+    static primitive_impl* create(const experimental_detectron_roi_feature_extractor_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        const auto output_layout = impl_param->output_layout;
         const auto padding_filling_value = output_layout.data_padding.filling_value();
         CLDNN_ERROR_NOT_EQUAL(arg.id(),
                               "experimental_detectron_roi_feature_extractor padding filling value",
@@ -48,14 +49,12 @@ struct experimental_detectron_roi_feature_extractor_impl : public typed_primitiv
                               "padding mode",
                               0.0f,
                               "Unknown padding mode in experimental_detectron_roi_feature_extractor.");
-
-        auto params = get_default_params<kernel_selector::experimental_detectron_roi_feature_extractor_params>(arg);
+        auto params = get_default_params<kernel_selector::experimental_detectron_roi_feature_extractor_params>(*impl_param);
         auto optional_params = get_default_optional_params<kernel_selector::experimental_detectron_roi_feature_extractor_optional_params>(arg.get_program());
 
-        const auto& primitive = arg.get_primitive();
         size_t number_of_inputs = primitive->input_size() - 1;
         for (std::size_t i = 1; i < number_of_inputs; i++) {
-            params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
         params.output_dim = primitive->output_dim;
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 fa33287cf158f6..97589c7e53b6ab 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
@@ -21,13 +21,12 @@ struct experimental_detectron_topk_rois_impl : typed_primitive_impl_ocl<experime
         return make_unique<experimental_detectron_topk_rois_impl>(*this);
     }
 
-    static primitive_impl *create(const experimental_detectron_topk_rois_node &arg) {
-        auto params = get_default_params<kernel_selector::experimental_detectron_topk_roi_params>(
-                arg);
+    static primitive_impl *create(const experimental_detectron_topk_rois_node &arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto params = get_default_params<kernel_selector::experimental_detectron_topk_roi_params>(*impl_param);
         const auto& experimental_detectron_topk_rois_kernel_selector =
                 kernel_selector::experimental_detectron_topk_rois_kernel_selector::Instance();
-        const auto& primitive = arg.get_primitive();
-        params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
         params.max_rois = primitive->max_rois;
         auto best_kernels = experimental_detectron_topk_rois_kernel_selector.GetBestKernels(params,
                                                                                             kernel_selector::experimental_detectron_topk_roi_optional_params());
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 38083b4ee17651..33131d073c548b 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
@@ -23,15 +23,16 @@ struct extract_image_patches_impl : typed_primitive_impl_ocl<extract_image_patch
     }
 
 public:
-    static primitive_impl* create(const extract_image_patches_node& arg) {
-        auto params = get_default_params<kernel_selector::extract_image_patches_params>(arg);
+    static primitive_impl* create(const extract_image_patches_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto params = get_default_params<kernel_selector::extract_image_patches_params>(*impl_param);
         auto optional_params =
             get_default_optional_params<kernel_selector::extract_image_patches_optional_params>(arg.get_program());
 
-        params.sizes = arg.get_primitive()->sizes;
-        params.strides = arg.get_primitive()->strides;
-        params.rates = arg.get_primitive()->rates;
-        params.auto_pad = arg.get_primitive()->auto_pad;
+        params.sizes = prim->sizes;
+        params.strides = prim->strides;
+        params.rates = prim->rates;
+        params.auto_pad = prim->auto_pad;
 
         auto& kernel_selector = kernel_selector::extract_image_patches_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(params, optional_params);
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 2ea1e22bf72a93..36ae094934063f 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
@@ -40,21 +40,20 @@ struct fully_connected_impl : typed_primitive_impl_ocl<fully_connected> {
     }
 
 public:
-    static primitive_impl* create(const fully_connected_node& arg) {
-        auto fc_params = get_weights_bias_default_params<kernel_selector::fully_connected_params>(arg);
+    static primitive_impl* create(const fully_connected_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto primitive = arg.get_primitive();
+        auto fc_params = get_weights_bias_default_params<kernel_selector::fully_connected_params>(*impl_param);
         auto fc_optional_params =
             get_default_weights_bias_optional_params<kernel_selector::fully_connected_optional_params>(
                 arg.get_program());
         fc_optional_params.allowInputReordering = true;
 
-        const auto primitive = arg.get_primitive();
-
         if (primitive->input_size != 3)
             fc_params.outputs = { fc_params.outputs[0].FlattenFeatureAndSpatials() };
 
         bool is_quantized = true;
-        for (auto& input : arg.get_dependencies())
-            is_quantized &= data_type_traits::is_quantized(input->get_output_layout().data_type);
+        for (auto& input : impl_param->input_layouts)
+            is_quantized &= data_type_traits::is_quantized(input.data_type);
 
         if (is_quantized) {
             fc_params.quantization = kernel_selector::QuantizationType::SYMMETRIC;
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 c309520291d624..434724d7b5338a 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gather.cpp
@@ -68,17 +68,18 @@ struct gather_impl : typed_primitive_impl_ocl<gather> {
     }
 
 public:
-    static primitive_impl* create(const gather_node& arg) {
-        auto gather_params = get_default_params<kernel_selector::gather_params>(arg);
+    static primitive_impl* create(const gather_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto gather_params = get_default_params<kernel_selector::gather_params>(*impl_param);
         auto gather_optional_params =
             get_default_optional_params<kernel_selector::gather_optional_params>(arg.get_program());
 
-        auto input_layout = arg.get_dependency(0).get_output_layout();
-        gather_params.axis = convert_axis(arg.get_primitive()->axis, input_layout.get_rank());
-        gather_params.batch_dim = size_t(arg.get_primitive()->batch_dim);
-        gather_params.support_neg_ind = arg.get_primitive()->support_neg_ind;
+        auto input_layout = impl_param->input_layouts[0];
+        gather_params.axis = convert_axis(prim->axis, input_layout.get_rank());
+        gather_params.batch_dim = size_t(prim->batch_dim);
+        gather_params.support_neg_ind = prim->support_neg_ind;
 
-        gather_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
+        gather_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
 
         auto& kernel_selector = kernel_selector::gather_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(gather_params, gather_optional_params);
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 d0b004c90fce93..e4b45e6fac4210 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
@@ -42,14 +42,15 @@ struct gather_elements_impl : typed_primitive_impl_ocl<gather_elements> {
     }
 
 public:
-    static primitive_impl* create(const gather_elements_node& arg) {
-        auto gather_elements_params = get_default_params<kernel_selector::gather_elements_params>(arg);
+    static primitive_impl* create(const gather_elements_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto gather_elements_params = get_default_params<kernel_selector::gather_elements_params>(*impl_param);
         auto gather_elements_optional_params =
             get_default_optional_params<kernel_selector::gather_elements_optional_params>(arg.get_program());
 
-        gather_elements_params.axis = convert_axis(arg.get_primitive()->axis);
+        gather_elements_params.axis = convert_axis(prim->axis);
 
-        gather_elements_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
+        gather_elements_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
 
         auto& kernel_selector = kernel_selector::gather_elements_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(gather_elements_params, gather_elements_optional_params);
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 9291c1977b26c8..03b8cfe03c83a7 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
@@ -22,16 +22,17 @@ struct gather_nd_impl : typed_primitive_impl_ocl<gather_nd> {
         return make_unique<gather_nd_impl>(*this);
     }
 
-    static primitive_impl* create(const gather_nd_node& arg) {
-        auto gather_nd_params = get_default_params<kernel_selector::gather_nd_params>(arg);
+    static primitive_impl* create(const gather_nd_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto gather_nd_params = get_default_params<kernel_selector::gather_nd_params>(*impl_param);
         auto gather_nd_optional_params =
             get_default_optional_params<kernel_selector::gather_nd_optional_params>(arg.get_program());
 
-        gather_nd_params.indices_rank = arg.get_primitive()->indices_rank;
-        gather_nd_params.batch_dims = arg.get_primitive()->batch_dims;
-        gather_nd_params.batch_merged_output = arg.get_primitive()->batch_merged_output;
+        gather_nd_params.indices_rank = prim->indices_rank;
+        gather_nd_params.batch_dims = prim->batch_dims;
+        gather_nd_params.batch_merged_output = prim->batch_merged_output;
 
-        gather_nd_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
+        gather_nd_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
 
         auto& kernel_selector = kernel_selector::gather_nd_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(gather_nd_params, gather_nd_optional_params);
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 f519b49efc64fc..51c405a1939bb9 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
@@ -22,14 +22,14 @@ struct gather_tree_impl : typed_primitive_impl_ocl<gather_tree> {
         return make_unique<gather_tree_impl>(*this);
     }
 
-    static primitive_impl* create(const gather_tree_node& arg) {
-        auto b_params = get_default_params<kernel_selector::gather_tree_params>(arg, 1);
+    static primitive_impl* create(const gather_tree_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto desc = arg.get_primitive();
+        auto b_params = get_default_params<kernel_selector::gather_tree_params>(*impl_param, 1);
         auto b_optional_params = get_default_optional_params<kernel_selector::gather_tree_optional_params>(arg.get_program());
 
         for (size_t i = 1; i < arg.get_dependencies().size(); i++) {
-            b_params.inputs.push_back(convert_data_tensor(arg.get_dependency(i).get_output_layout(), 1));
+            b_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i], 1));
         }
-        auto desc = arg.get_primitive();
 
         auto& kernel_selector = kernel_selector::gather_tree_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(b_params, b_optional_params);
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 6dd549a7666151..d5ff619b204bfe 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/gemm.cpp
@@ -23,24 +23,24 @@ struct gemm_impl : typed_primitive_impl_ocl<gemm> {
     }
 
 public:
-    static primitive_impl* create(const gemm_node& arg) {
-        auto gemm_params = get_default_params<kernel_selector::gemm_params>(arg, 1);
+    static primitive_impl* create(const gemm_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto desc = arg.get_primitive();
+        auto gemm_params = get_default_params<kernel_selector::gemm_params>(*impl_param, 1);
         auto gemm_optional_params =
             get_default_optional_params<kernel_selector::gemm_optional_params>(arg.get_program());
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            gemm_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            gemm_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
-        auto desc = arg.get_primitive();
         gemm_params.alpha = desc->alpha;
         gemm_params.beta = desc->beta;
         gemm_params.transpose_input0 = desc->transpose_input0;
         gemm_params.transpose_input1 = desc->transpose_input1;
 
         bool is_quantized = true;
-        for (auto& input : arg.get_dependencies())
-            is_quantized &= data_type_traits::is_quantized(input->get_output_layout().data_type);
+        for (auto& input : impl_param->input_layouts)
+            is_quantized &= data_type_traits::is_quantized(input.data_type);
 
         if (is_quantized) {
             gemm_params.quantization = kernel_selector::QuantizationType::SYMMETRIC;
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 c6e715b1299418..c958be7780ee9b 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
@@ -105,7 +105,7 @@ struct generic_layer_cpu : typed_primitive_impl<generic_layer> {
     void init_kernels() override {}
 };
 
-static primitive_impl* create(const generic_layer_node& arg) {
+static primitive_impl* create(const generic_layer_node& arg, std::shared_ptr<kernel_impl_params>) {
     if (arg.get_primitive()->generic_params.engine == kernel_selector::generic_kernel_params::Engine::GPU) {
         return new generic_layer_impl(arg);
     } else {
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 089be7f615814e..9f404ba258ed52 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/grn.cpp
@@ -26,11 +26,12 @@ struct grn_impl : typed_primitive_impl_ocl<grn> {
     }
 
 public:
-    static primitive_impl* create(const grn_node& arg) {
-        auto grn_params = get_default_params<kernel_selector::grn_params>(arg);
+    static primitive_impl* create(const grn_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto grn_params = get_default_params<kernel_selector::grn_params>(*impl_param);
         auto grn_optional_params = get_default_optional_params<kernel_selector::grn_optional_params>(arg.get_program());
 
-        grn_params.bias = arg.get_primitive()->bias;
+        grn_params.bias = prim->bias;
 
         auto& kernel_selector = kernel_selector::grn_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(grn_params, grn_optional_params);
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 90c429f9c66dde..959ffce8cc8049 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/lrn.cpp
@@ -21,11 +21,10 @@ struct lrn_impl : typed_primitive_impl_ocl<lrn> {
         return make_unique<lrn_impl>(*this);
     }
 
-    static primitive_impl* create(const lrn_node& arg) {
-        auto lrn_params = get_default_params<kernel_selector::lrn_params>(arg);
-        auto lrn_optional_params = get_default_optional_params<kernel_selector::lrn_optional_params>(arg.get_program());
-
+    static primitive_impl* create(const lrn_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         const auto& primitive = arg.get_primitive();
+        auto lrn_params = get_default_params<kernel_selector::lrn_params>(*impl_param);
+        auto lrn_optional_params = get_default_optional_params<kernel_selector::lrn_optional_params>(arg.get_program());
 
         lrn_params.alpha = primitive->alpha;
         lrn_params.beta = primitive->beta;
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 2e6dfa8ba5fbf0..4a7b5da78eab64 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
@@ -34,19 +34,23 @@ struct lstm_dynamic_input_impl : typed_primitive_impl_ocl<lstm_dynamic_input> {
     }
 
 public:
-    static primitive_impl* create(const lstm_dynamic_input_node& arg) {
-        auto dlstm_input_params = get_default_params<kernel_selector::lstm_dynamic_input_params>(arg);
+    static primitive_impl* create(const lstm_dynamic_input_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto dlstm_input_params = get_default_params<kernel_selector::lstm_dynamic_input_params>(*impl_param);
 
-        const auto& weights_layout = arg.weights().get_output_layout();
+        const auto dyn_len_idx = 1;
+        const auto weights_idx = 2;
+        const auto bias_idx = 3;
+
+        const auto& weights_layout = impl_param->input_layouts[weights_idx];
         dlstm_input_params.weights = convert_weights_tensor(weights_layout);
 
         if (arg.bias_term()) {
-            const auto& bias_layout = arg.bias().get_output_layout();
+            const auto& bias_layout = impl_param->input_layouts[bias_idx];
             dlstm_input_params.bias.push_back(convert_data_tensor(bias_layout));
         }
 
         // dyn length
-        const auto& dyn_length_tensor = arg.dyn_length().get_output_layout();
+        const auto& dyn_length_tensor = impl_param->input_layouts[dyn_len_idx];
         dlstm_input_params.inputs.push_back(convert_data_tensor(dyn_length_tensor));
 
         dlstm_input_params.direction = arg.direction();
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 cec50564903f4f..ac549b71ea0a7d 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
@@ -39,36 +39,36 @@ struct lstm_dynamic_timeloop_impl : typed_primitive_impl_ocl<lstm_dynamic_timelo
     }
 
 public:
-    static primitive_impl* create(const lstm_dynamic_timeloop_node& arg) {
-        auto dlstm_timeloop_params = get_default_params<kernel_selector::lstm_dynamic_timeloop_params>(arg);
+    static primitive_impl* create(const lstm_dynamic_timeloop_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto dlstm_timeloop_params = get_default_params<kernel_selector::lstm_dynamic_timeloop_params>(*impl_param);
 
         // dyn length
-        const auto& dyn_length_tensor = arg.dyn_length().get_output_layout();
+        const auto& dyn_length_tensor = impl_param->input_layouts[arg.get_dependency_idx("dyn_length")];
         dlstm_timeloop_params.inputs.push_back(convert_data_tensor(dyn_length_tensor));
 
         // recurrent
-        const auto& recurrent_layout = arg.recurrent().get_output_layout();
+        const auto& recurrent_layout = impl_param->input_layouts[arg.get_dependency_idx("recurrent")];
         dlstm_timeloop_params.recurrent = convert_data_tensor(recurrent_layout);
 
         dlstm_timeloop_params.direction = arg.direction();
 
         if (arg.initial_cell_term()) {
-            const auto& cell_layout = arg.initial_cell().get_output_layout();
+            const auto& cell_layout = impl_param->input_layouts[arg.get_dependency_idx("initial_cell")];
             dlstm_timeloop_params.set_cell(convert_data_tensor(cell_layout));
         }
 
         if (arg.last_hidden_output_term()) {
-            const auto& last_hidden_output_layout = arg.last_hidden_state().get_output_layout();
+            const auto& last_hidden_output_layout = impl_param->input_layouts[arg.get_dependency_idx("last_hidden_output")];
             dlstm_timeloop_params.set_last_hidden_output(convert_data_tensor(last_hidden_output_layout));
         }
 
         if (arg.initial_hidden_term()) {
-            const auto& hidden_layout = arg.initial_hidden().get_output_layout();
+            const auto& hidden_layout = impl_param->input_layouts[arg.get_dependency_idx("initial_hidden")];
             dlstm_timeloop_params.set_hidden(convert_data_tensor(hidden_layout));
         }
 
         if (arg.last_cell_output_term()) {
-            const auto& last_cell_state_layout = arg.last_cell_state().get_output_layout();
+            const auto& last_cell_state_layout = impl_param->input_layouts[arg.get_dependency_idx("last_cell_output")];
             dlstm_timeloop_params.set_last_cell_output(convert_data_tensor(last_cell_state_layout));
         }
 
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 959c9e13873893..0978e7363e839f 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
@@ -34,13 +34,15 @@ struct lstm_elt_impl : typed_primitive_impl_ocl<lstm_elt> {
     }
 
 public:
-    static primitive_impl* create(const lstm_elt_node& arg) {
-        auto lstm_elt_params = get_default_params<kernel_selector::lstm_elt_params>(arg);
+    static primitive_impl* create(const lstm_elt_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto lstm_elt_params = get_default_params<kernel_selector::lstm_elt_params>(*impl_param);
         auto lstm_elt_optional_params =
             get_default_optional_params<kernel_selector::lstm_elt_optional_params>(arg.get_program());
 
         if (arg.cell_term()) {
-            const auto& cell_layout = arg.cell().get_output_layout();
+            const auto& cell_idx = 1;
+            const auto& cell_layout = impl_param->input_layouts[cell_idx];
             lstm_elt_params.SetCell(convert_data_tensor(cell_layout));
             // TODO: make a generic function to get the direction
             if (cell_layout.spatial(1) > 1) {
@@ -48,7 +50,6 @@ struct lstm_elt_impl : typed_primitive_impl_ocl<lstm_elt> {
             }
         }
 
-        const auto& prim = arg.get_primitive();
         if (!prim->activations.empty()) {
             auto a_sz = prim->activations.size();
             auto param_sz = prim->activation_params.size();
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 e69a361ca06ae1..35041425fc1c32 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
@@ -37,21 +37,26 @@ struct lstm_gemm_impl : typed_primitive_impl_ocl<lstm_gemm> {
     }
 
 public:
-    static primitive_impl* create(const lstm_gemm_node& arg) {
-        const auto& weights_layout = arg.weights().get_output_layout();
-
-        auto lstm_gemm_params = get_default_params<kernel_selector::lstm_gemm_params>(arg);
+    static primitive_impl* create(const lstm_gemm_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto input_idx = 0;
+        const auto weight_idx = 1;
+        const auto recurrent_idx = 2;
+        const auto bias_idx = 3;
+        const auto hidden_idx = arg.bias_term() ? 4 : 3;
+
+        const auto& weights_layout = impl_param->input_layouts[weight_idx];
+        auto lstm_gemm_params = get_default_params<kernel_selector::lstm_gemm_params>(*impl_param);
         lstm_gemm_params.weights = convert_data_tensor(weights_layout);
 
         if (arg.bias_term()) {
-            const auto& bias_layout = arg.bias().get_output_layout();
+            const auto& bias_layout = impl_param->input_layouts[bias_idx];
             lstm_gemm_params.SetBias(convert_data_tensor(bias_layout));
         }
         if (arg.hidden_term()) {
-            const auto& recurrent_layout = arg.recurrent().get_output_layout();
+            const auto& recurrent_layout = impl_param->input_layouts[recurrent_idx];
             lstm_gemm_params.recurrent = convert_data_tensor(recurrent_layout);
 
-            const auto& hidden_layout = arg.hidden().get_output_layout();
+            const auto& hidden_layout = impl_param->input_layouts[hidden_idx];
             lstm_gemm_params.SetHidden(convert_data_tensor(hidden_layout));
             // TODO: make a generic function to get the direction
             if (hidden_layout.spatial(1) > 1) {
@@ -61,7 +66,7 @@ struct lstm_gemm_impl : typed_primitive_impl_ocl<lstm_gemm> {
         lstm_gemm_params.direction = arg.direction();
 
         // Update the direction of the input for the gemm kernel
-        const auto& input_layout = arg.input().get_output_layout();
+        const auto& input_layout = impl_param->input_layouts[input_idx];
         size_t input_directions = input_layout.spatial(1);
 
         if (input_directions > 1) {  // For bidirection input, input direction can be 1 or 0
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/max_unpooling.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/max_unpooling.cpp
index 72d3ebe5d9590f..36b680b5f99fb6 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/max_unpooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/max_unpooling.cpp
@@ -40,12 +40,13 @@ struct max_unpooling_impl : typed_primitive_impl_ocl<max_unpooling> {
         return parent::execute_impl(tmp_events, instance);
     }
 
-    static primitive_impl* create(const max_unpooling_node& arg) {
-        auto max_unpooling_params = get_default_params<kernel_selector::max_unpooling_params>(arg);
+    static primitive_impl* create(const max_unpooling_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto max_unpooling_params = get_default_params<kernel_selector::max_unpooling_params>(*impl_param);
         auto max_unpooling_optional_params =
             get_default_optional_params<kernel_selector::max_unpooling_optional_params>(arg.get_program());
 
-        max_unpooling_params.inputs.push_back(convert_data_tensor(arg.argmax().get_output_layout()));
+        const auto max_idx = 1;
+        max_unpooling_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[max_idx]));
 
         auto& kernel_selector = kernel_selector::max_unpooling_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(max_unpooling_params, max_unpooling_optional_params);
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 3d1b88caf02071..a6c043cb7bdb2c 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
@@ -18,7 +18,7 @@ struct mutable_data_impl : public typed_primitive_impl_ocl<mutable_data> {
     }
 
 public:
-    static primitive_impl* create(mutable_data_node const& arg) { return new mutable_data_impl(arg, {}); }
+    static primitive_impl* create(mutable_data_node const& arg, std::shared_ptr<kernel_impl_params>) { return new mutable_data_impl(arg, {}); }
 };
 
 namespace detail {
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 ff993b6ffc71e9..b3c36ce39eea78 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/mvn.cpp
@@ -26,16 +26,17 @@ struct mvn_impl : typed_primitive_impl_ocl<mvn> {
     }
 
 public:
-    static primitive_impl* create(const mvn_node& arg) {
-        auto mvn_params = get_default_params<kernel_selector::mvn_params>(arg);
+    static primitive_impl* create(const mvn_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto mvn_params = get_default_params<kernel_selector::mvn_params>(*impl_param);
         auto mvn_optional_params = get_default_optional_params<kernel_selector::mvn_optional_params>(arg.get_program());
 
-        mvn_params.mvnMode = arg.get_primitive()->across_channels ? kernel_selector::mvn_mode::ACROSS_CHANNELS
+        mvn_params.mvnMode = prim->across_channels ? kernel_selector::mvn_mode::ACROSS_CHANNELS
                                                                   : kernel_selector::mvn_mode::WITHIN_CHANNELS;
-        mvn_params.mvnNormalizeVariance = arg.get_primitive()->normalize_variance;
-        mvn_params.epsilon = arg.get_primitive()->epsilon;
+        mvn_params.mvnNormalizeVariance = prim->normalize_variance;
+        mvn_params.epsilon = prim->epsilon;
 
-        mvn_params.mvnEpsMode = arg.get_primitive()->eps_inside_sqrt ? kernel_selector::mvn_eps_mode::INSIDE_SQRT
+        mvn_params.mvnEpsMode = prim->eps_inside_sqrt ? kernel_selector::mvn_eps_mode::INSIDE_SQRT
                                                                      : kernel_selector::mvn_eps_mode::OUTSIDE_SQRT;
 
         auto& kernel_selector = kernel_selector::mvn_kernel_selector::Instance();
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 37e5bac447ff05..df40e77ab7374b 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
@@ -53,13 +53,14 @@ struct non_max_suppression_impl : typed_primitive_impl_ocl<non_max_suppression>
     }
 
 public:
-    static primitive_impl* create(const non_max_suppression_node& arg) {
-        auto params = get_default_params<kernel_selector::non_max_suppression_params>(arg);
+    static primitive_impl* create(const non_max_suppression_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto params = get_default_params<kernel_selector::non_max_suppression_params>(*impl_param);
         auto optional_params =
             get_default_optional_params<kernel_selector::non_max_suppression_optional_params>(arg.get_program());
 
-        const auto& primitive = arg.get_primitive();
-        params.inputs.push_back(convert_data_tensor(arg.input_scores().get_output_layout()));
+        const auto input_scores_idx = 1;
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[input_scores_idx]));
 
         if (arg.has_num_select_per_class()) {
             cldnn::program_node& node = arg.num_select_per_class_node();
@@ -68,7 +69,7 @@ struct non_max_suppression_impl : typed_primitive_impl_ocl<non_max_suppression>
                 params.num_select_per_class = get_value<int>(node);
             } else {
                 params.num_select_per_class_type = kernel_selector::NmsArgType::Input;
-                params.inputs.push_back(convert_data_tensor(node.get_output_layout()));
+                params.inputs.push_back(convert_data_tensor(impl_param->output_layout));
             }
         }
 
@@ -79,7 +80,7 @@ struct non_max_suppression_impl : typed_primitive_impl_ocl<non_max_suppression>
                 params.iou_threshold = get_value<float>(node);
             } else {
                 params.iou_threshold_type = kernel_selector::NmsArgType::Input;
-                params.inputs.push_back(convert_data_tensor(node.get_output_layout()));
+                params.inputs.push_back(convert_data_tensor(impl_param->output_layout));
             }
         }
 
@@ -90,7 +91,7 @@ struct non_max_suppression_impl : typed_primitive_impl_ocl<non_max_suppression>
                 params.score_threshold = get_value<float>(node);
             } else {
                 params.score_threshold_type = kernel_selector::NmsArgType::Input;
-                params.inputs.push_back(convert_data_tensor(node.get_output_layout()));
+                params.inputs.push_back(convert_data_tensor(impl_param->output_layout));
             }
         }
 
@@ -101,21 +102,28 @@ struct non_max_suppression_impl : typed_primitive_impl_ocl<non_max_suppression>
                 params.soft_nms_sigma = get_value<float>(node);
             } else {
                 params.soft_nms_sigma_type = kernel_selector::NmsArgType::Input;
-                params.inputs.push_back(convert_data_tensor(node.get_output_layout()));
+                params.inputs.push_back(convert_data_tensor(impl_param->output_layout));
             }
         }
 
+        auto get_additional_output_node_idx = [&] (bool is_third) {
+            size_t offset = 2;
+            offset += arg.has_num_select_per_class();
+            offset += arg.has_iou_threshold();
+            offset += arg.has_score_threshold();
+            offset += arg.has_soft_nms_sigma();
+            if (is_third)
+                offset += arg.has_second_output();
+            return offset;
+        };
+
         if (arg.has_second_output()) {
-            layout second_output_layout = arg.second_output_node().get_output_layout();
-            second_output_layout.format = arg.input_scores().get_output_layout().format;
-            params.inputs.push_back(convert_data_tensor(second_output_layout));
+            params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[get_additional_output_node_idx(false)]));
             params.has_second_output = true;
         }
 
         if (arg.has_third_output()) {
-            layout third_output_layout = arg.third_output_node().get_output_layout();
-            third_output_layout.format = arg.input_scores().get_output_layout().format;
-            params.inputs.push_back(convert_data_tensor(third_output_layout));
+            params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[get_additional_output_node_idx(true)]));
             params.has_third_output = true;
         }
 
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 0b4280def2a075..b81625c96fa6ef 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/normalize.cpp
@@ -33,16 +33,17 @@ struct normalize_impl : typed_primitive_impl_ocl<normalize> {
     }
 
 public:
-    static primitive_impl* create(const normalize_node& arg) {
-        auto norm_params = get_default_params<kernel_selector::normalize_params>(arg);
+    static primitive_impl* create(const normalize_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto norm_params = get_default_params<kernel_selector::normalize_params>(*impl_param);
         auto norm_optional_params =
             get_default_optional_params<kernel_selector::normalize_optional_params>(arg.get_program());
 
-        const auto& scale_layout = arg.scale().get_output_layout();
+        const auto& scale_layout = impl_param->input_layouts[1];
 
-        norm_params.normMode = arg.get_primitive()->across_spatial ? kernel_selector::normalize_mode::ACROSS_SPATIAL
+        norm_params.normMode = prim->across_spatial ? kernel_selector::normalize_mode::ACROSS_SPATIAL
                                                                    : kernel_selector::normalize_mode::WITHIN_SPATIAL;
-        norm_params.epsilon = arg.get_primitive()->epsilon;
+        norm_params.epsilon = prim->epsilon;
         norm_params.scaleTable = convert_data_tensor(scale_layout).FlattenFeatureAndSpatials();
 
         auto& kernel_selector = kernel_selector::normalize_kernel_selector::Instance();
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 482e1b16c70d5c..0981927d845cc2 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
@@ -23,16 +23,17 @@ struct one_hot_impl : typed_primitive_impl_ocl<one_hot> {
         return make_unique<one_hot_impl>(*this);
     }
 
-    static primitive_impl* create(const one_hot_node& arg) {
-        auto oh_params = get_default_params<kernel_selector::one_hot_params>(arg, 1);
+    static primitive_impl* create(const one_hot_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto oh_params = get_default_params<kernel_selector::one_hot_params>(*impl_param, 1);
         auto oh_optional_params =
             get_default_optional_params<kernel_selector::one_hot_optional_params>(arg.get_program());
 
-        oh_params.one_hot_axis = arg.get_primitive()->one_hot_axis;
-        oh_params.on_value = arg.get_primitive()->on_value;
-        oh_params.off_value = arg.get_primitive()->off_value;
+        oh_params.one_hot_axis = prim->one_hot_axis;
+        oh_params.on_value = prim->on_value;
+        oh_params.off_value = prim->off_value;
 
-        auto output_sizes = arg.get_output_layout().get_dims();
+        auto output_sizes = impl_param->output_layout.get_dims();
 
         oh_params.one_hot_limit = output_sizes[oh_params.one_hot_axis];
 
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 68ddafbb1277fa..e8655297659882 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/permute.cpp
@@ -50,13 +50,14 @@ struct permute_impl : typed_primitive_impl_ocl<permute> {
         return make_unique<permute_impl>(*this);
     }
 
-    static primitive_impl* create(const permute_node& arg) {
-        auto permute_params = get_default_params<kernel_selector::permute_params>(arg);
+    static primitive_impl* create(const permute_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto permute_params = get_default_params<kernel_selector::permute_params>(*impl_param);
         auto permute_optional_params =
             get_default_optional_params<kernel_selector::permute_optional_params>(arg.get_program());
 
-        auto in_rank = arg.get_dependency(0).get_output_layout().get_rank();
-        auto permute_order = convert_permute_order(arg.get_primitive()->permute_order, in_rank);
+        auto in_rank = impl_param->input_layouts[0].get_rank();
+        auto permute_order = convert_permute_order(prim->permute_order, in_rank);
         permute_params.order = permute_order;
         auto& kernel_selector = kernel_selector::permute_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(permute_params, permute_optional_params);
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 09673fde42766b..ace6a61c0f9e0c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/pooling.cpp
@@ -77,15 +77,13 @@ struct pooling_impl : typed_primitive_impl_ocl<pooling> {
     }
 
 public:
-    static primitive_impl* create(const pooling_node& arg) {
+    static primitive_impl* create(const pooling_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         validate_args(arg);
-
-        auto pool_params = get_default_params<kernel_selector::pooling_params>(arg);
+        const auto primitive = arg.get_primitive();
+        auto pool_params = get_default_params<kernel_selector::pooling_params>(*impl_param);
         auto pool_optional_params =
             get_default_optional_params<kernel_selector::pooling_optional_params>(arg.get_program());
 
-        const auto primitive = arg.get_primitive();
-
         pool_params.maxPoolOpset8Features = primitive->maxPoolOpset8Features;
         if (pool_params.maxPoolOpset8Features) {
             switch (primitive->index_element_type) {
@@ -107,8 +105,8 @@ struct pooling_impl : typed_primitive_impl_ocl<pooling> {
         const auto& pad = primitive->pad;
         const auto& dilation = primitive->dilation;
         auto kernel = primitive->size;
-        const auto& input_layout = arg.input().get_output_layout();
-        const auto& output_layout = arg.get_output_layout();
+        const auto& input_layout = impl_param->input_layouts[0];
+        const auto& output_layout = impl_param->output_layout;
         auto spatial_rank = output_layout.get_spatial_rank();
 
         auto& pp = pool_params;
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 ab7da77053eb65..69f32ba4b3e6b4 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
@@ -23,23 +23,27 @@ struct pyramid_roi_align_impl : typed_primitive_impl_ocl<pyramid_roi_align> {
         return make_unique<pyramid_roi_align_impl>(*this);
     }
 
-    static primitive_impl* create(const pyramid_roi_align_node& arg) {
+    static primitive_impl* create(const pyramid_roi_align_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         auto prim = arg.get_primitive();
-        auto params = get_default_params<kernel_selector::PyramidROIAlign_params>(arg, 1);
+        auto params = get_default_params<kernel_selector::PyramidROIAlign_params>(*impl_param, 1);
         auto optional_params =
             get_default_optional_params<kernel_selector::PyramidROIAlign_optional_params>(arg.get_program());
 
-        params.inputs.push_back(convert_data_tensor(arg.P2().get_output_layout()));
-        params.inputs.push_back(convert_data_tensor(arg.P3().get_output_layout()));
-        params.inputs.push_back(convert_data_tensor(arg.P4().get_output_layout()));
-        params.inputs.push_back(convert_data_tensor(arg.P5().get_output_layout()));
+        const auto P2_idx = 1;
+        const auto P3_idx = 2;
+        const auto P4_idx = 3;
+        const auto P5_idx = 4;
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[P2_idx]));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[P3_idx]));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[P4_idx]));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[P5_idx]));
 
         params.sampling_ratio_x = prim->sampling_ratio;
         params.sampling_ratio_y = prim->sampling_ratio;
 
         auto first_layer_scale = prim->pyramid_scales[0];
-        auto image_size_x = arg.P2().get_output_layout().spatial(0) * first_layer_scale;
-        auto image_size_y = arg.P2().get_output_layout().spatial(1) * first_layer_scale;
+        auto image_size_x = impl_param->input_layouts[P2_idx].spatial(0) * first_layer_scale;
+        auto image_size_y = impl_param->input_layouts[P2_idx].spatial(1) * first_layer_scale;
         params.image_size_x = image_size_x;
         params.image_size_y = image_size_y;
 
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 b73a4f69758216..e0bddaecb645ab 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
@@ -43,8 +43,8 @@ struct quantize_impl : typed_primitive_impl_ocl<quantize> {
     }
 
 public:
-    static primitive_impl* create(const quantize_node& arg) {
-        auto quantize_params = get_default_params<kernel_selector::quantize_params>(arg);
+    static primitive_impl* create(const quantize_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto quantize_params = get_default_params<kernel_selector::quantize_params>(*impl_param);
         auto quantize_optional_params =
             get_default_optional_params<kernel_selector::quantize_optional_params>(arg.get_program());
 
@@ -75,9 +75,9 @@ struct quantize_impl : typed_primitive_impl_ocl<quantize> {
         quantize_params.out_shift = arg.get_output_shift_val();
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            quantize_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            quantize_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
-        const auto& output_layout = arg.get_output_layout();
+        const auto& output_layout = impl_param->output_layout;
         quantize_params.outputs = { convert_data_tensor(output_layout) };
 
         auto& kernel_selector = kernel_selector::quantize_kernel_selector::Instance();
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 5334aa972b0529..1bc142234237f6 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
@@ -21,16 +21,15 @@ struct random_uniform_impl : typed_primitive_impl_ocl<random_uniform> {
         return make_unique<random_uniform_impl>(*this);
     }
 
-    static primitive_impl *create(const random_uniform_node &arg) {
-        auto params = get_default_params<kernel_selector::random_uniform_params>(
-                arg);
+    static primitive_impl *create(const random_uniform_node &arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto &primitive = arg.get_primitive();
+        auto params = get_default_params<kernel_selector::random_uniform_params>(*impl_param);
         auto &random_uniform_kernel_selector =
                 kernel_selector::random_uniform_kernel_selector::Instance();
-        const auto &primitive = arg.get_primitive();
         params.global_seed = primitive->global_seed;
         params.op_seed = primitive->op_seed;
-        params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
-        params.inputs.push_back(convert_data_tensor(arg.input(2).get_output_layout()));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
+        params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
         auto best_kernels = random_uniform_kernel_selector.GetBestKernels(params,
                                                                           kernel_selector::random_uniform_optional_params());
         CLDNN_ERROR_BOOL(arg.id(),
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 ffdb35a1e32584..370aa0579a5b15 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/range.cpp
@@ -20,10 +20,10 @@ struct range_impl : typed_primitive_impl_ocl<range> {
         return make_unique<range_impl>(*this);
     }
 
-    static primitive_impl* create(const range_node& arg) {
-        auto params = get_default_params<kernel_selector::range_params>(arg);
+    static primitive_impl* create(const range_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::range_params>(*impl_param);
         for (int i : {1, 2})
-            params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         auto optional_params =
             get_default_optional_params<kernel_selector::range_optional_params>(arg.get_program());
 
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 ca1709d8db68a5..80a319c6bff7bb 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reduce.cpp
@@ -58,13 +58,14 @@ struct reduce_impl : typed_primitive_impl_ocl<reduce> {
     }
 
 public:
-    static primitive_impl* create(const reduce_node& arg) {
-        auto reduce_params = get_default_params<kernel_selector::reduce_params>(arg);
+    static primitive_impl* create(const reduce_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto reduce_params = get_default_params<kernel_selector::reduce_params>(*impl_param);
         auto reduce_optional_params = get_default_optional_params<kernel_selector::reduce_optional_params>(arg.get_program());
 
-        reduce_params.reduceAxes = arg.get_primitive()->axes;
-        reduce_params.keepDims = arg.get_primitive()->keep_dims;
-        reduce_params.reduceMode = cldnn_2_reduce_mode(arg.get_primitive()->mode);
+        reduce_params.reduceAxes = prim->axes;
+        reduce_params.keepDims = prim->keep_dims;
+        reduce_params.reduceMode = cldnn_2_reduce_mode(prim->mode);
 
         auto& kernel_selector = kernel_selector::reduce_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(reduce_params, reduce_optional_params);
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 c785470315da40..2b0449cf3615cd 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
@@ -21,8 +21,8 @@ struct region_yolo_impl : typed_primitive_impl_ocl<region_yolo> {
         return make_unique<region_yolo_impl>(*this);
     }
 
-    static primitive_impl* create(const region_yolo_node& arg) {
-        auto ry_params = get_default_params<kernel_selector::region_yolo_params>(arg);
+    static primitive_impl* create(const region_yolo_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto ry_params = get_default_params<kernel_selector::region_yolo_params>(*impl_param);
         auto ry_optional_params =
             get_default_optional_params<kernel_selector::region_yolo_optional_params>(arg.get_program());
 
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 8c56e21e426382..60f3e1e210bc13 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reorder.cpp
@@ -41,40 +41,40 @@ struct reorder_impl : typed_primitive_impl_ocl<reorder> {
     }
 
 public:
-    static primitive_impl* create(const reorder_node& arg) {
-        auto&& input_layout = arg.input().get_output_layout();
-        auto&& output_layout = arg.get_output_layout();
-
-        auto reorder_params = get_default_params<kernel_selector::reorder_params>(arg);
+    static primitive_impl* create(const reorder_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto&& output_layout = impl_param->output_layout;
+        auto reorder_params = get_default_params<kernel_selector::reorder_params>(*impl_param);
         auto reorder_optional_params =
             get_default_optional_params<kernel_selector::reorder_optional_params>(arg.get_program());
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            reorder_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            reorder_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
-        if (arg.get_output_layout().data_padding) {
+        if (impl_param->output_layout.data_padding) {
             reorder_params.has_padded_output = true;
         }
 
         if (arg.has_mean()) {
-            if (input_layout.format == cldnn::format::nv12) {
+            if (impl_param->input_layouts[0].format == cldnn::format::nv12) {
                 const auto& mean_layout = arg.mean_nv12().get_output_layout();
                 reorder_params.mean = convert_data_tensor(mean_layout);
                 reorder_params.mode = kernel_selector::mean_subtruct_mode::IN_BUFFER;
             } else {
-                const auto& mean_layout = arg.mean().get_output_layout();
+                const auto mean_idx = 1;
+                const auto& mean_layout = impl_param->input_layouts[mean_idx];
                 reorder_params.mean = convert_data_tensor(mean_layout);
                 reorder_params.mode = kernel_selector::mean_subtruct_mode::IN_BUFFER;
             }
-        } else if (arg.get_primitive()->subtract_per_feature.empty() == false) {
+        } else if (prim->subtract_per_feature.empty() == false) {
             reorder_params.mode = kernel_selector::mean_subtruct_mode::INSIDE_PARAMS;
-            reorder_params.meanValues = arg.get_primitive()->subtract_per_feature;
+            reorder_params.meanValues = prim->subtract_per_feature;
         } else {
             reorder_params.mode = kernel_selector::mean_subtruct_mode::NONE;
         }
 
         if (reorder_params.mode != kernel_selector::mean_subtruct_mode::NONE) {
-            switch (arg.get_primitive()->mean_mode) {
+            switch (prim->mean_mode) {
                 case reorder_mean_mode::none:
                     reorder_params.mean_op = kernel_selector::mean_op::NONE;
                     break;
@@ -98,7 +98,7 @@ struct reorder_impl : typed_primitive_impl_ocl<reorder> {
             reorder_params.winograd_nr_tiles_x = ceil_div(output_layout.spatial(0), 4);
         }
 
-        reorder_params.winograd = input_layout.format.is_winograd() || output_layout.format.is_winograd();
+        reorder_params.winograd = impl_param->input_layouts[0].format.is_winograd() || output_layout.format.is_winograd();
 
         auto& kernel_selector = kernel_selector::reorder_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(reorder_params, reorder_optional_params);
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 474d7ef645ef0b..58b6372bb3531f 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
@@ -21,13 +21,12 @@ struct reorg_yolo_impl : typed_primitive_impl_ocl<reorg_yolo> {
         return make_unique<reorg_yolo_impl>(*this);
     }
 
-    static primitive_impl* create(const reorg_yolo_node& arg) {
-        auto ry_params = get_default_params<kernel_selector::reorg_yolo_params>(arg);
+    static primitive_impl* create(const reorg_yolo_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto ry_params = get_default_params<kernel_selector::reorg_yolo_params>(*impl_param);
         auto ry_optional_params =
             get_default_optional_params<kernel_selector::reorg_yolo_optional_params>(arg.get_program());
 
-        const auto& primitive = arg.get_primitive();
-
         ry_params.stride = primitive->stride;
 
         auto& kernel_selector = kernel_selector::reorg_yolo_kernel_selector::Instance();
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 0f2dc1b0d87f4c..26a663fbb6ec84 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
@@ -104,13 +104,13 @@ struct resample_impl : typed_primitive_impl_ocl<resample> {
         return make_unique<resample_impl>(*this);
     }
 
-    static primitive_impl* create(const resample_node& arg) {
-        auto us_params = get_default_params<kernel_selector::resample_params>(arg);
+    static primitive_impl* create(const resample_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& primitive = arg.get_primitive();
+        auto us_params = get_default_params<kernel_selector::resample_params>(*impl_param);
         auto us_optional_params =
             get_default_optional_params<kernel_selector::resample_optional_params>(arg.get_program());
 
-        const auto& primitive = arg.get_primitive();
-        size_t dimsNum = arg.get_output_layout().format.dimension();
+        size_t dimsNum = impl_param->output_layout.format.dimension();
         us_params.resampleType = convert_to_sample_type(primitive->operation_type);
         us_params.nearestMode = convert_to_nearest_mode(primitive->round_mode);
         us_params.coordTransMode = convert_to_coord_transform_mode(primitive->coord_trans_mode);
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 9c3d53c2dcf8de..2e2d175650954c 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reshape.cpp
@@ -22,12 +22,11 @@ struct reshape_impl : public typed_primitive_impl_ocl<reshape> {
     }
 
 public:
-    static primitive_impl* create(reshape_node const& arg) {
+    static primitive_impl* create(reshape_node const& arg, std::shared_ptr<kernel_impl_params> impl_param) {
         if (arg.can_be_optimized()) {
             return new reshape_impl(arg, {});
         }
-
-        auto reorder_params = get_default_params<kernel_selector::reshape_params>(arg);
+        auto reorder_params = get_default_params<kernel_selector::reshape_params>(*impl_param);
         auto reorder_optional_params =
             get_default_optional_params<kernel_selector::reshape_optional_params>(arg.get_program());
 
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 2529756c7e47ab..f7ecf729353c56 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/reverse.cpp
@@ -24,8 +24,8 @@ struct reverse_impl : typed_primitive_impl_ocl<reverse> {
     }
 
 public:
-    static primitive_impl* create(const reverse_node& arg) {
-        auto params = get_default_params<kernel_selector::reverse_params>(arg);
+    static primitive_impl* create(const reverse_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::reverse_params>(*impl_param);
         const auto optional_params =
             get_default_optional_params<kernel_selector::reverse_optional_params>(arg.get_program());
 
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 cd212f7e3bbe60..217cad0daa2fd6 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
@@ -23,15 +23,16 @@ struct reverse_sequence_impl : typed_primitive_impl_ocl<reverse_sequence> {
     }
 
 public:
-    static primitive_impl* create(const reverse_sequence_node& arg) {
-        auto reverse_sequence_params = get_default_params<kernel_selector::reverse_sequence_params>(arg);
+    static primitive_impl* create(const reverse_sequence_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto reverse_sequence_params = get_default_params<kernel_selector::reverse_sequence_params>(*impl_param);
         auto reverse_sequence_optional_params =
             get_default_optional_params<kernel_selector::reverse_sequence_optional_params>(arg.get_program());
 
-        reverse_sequence_params.seq_axis = arg.get_primitive()->seq_axis;
-        reverse_sequence_params.batch_axis = arg.get_primitive()->batch_axis;
+        reverse_sequence_params.seq_axis = prim->seq_axis;
+        reverse_sequence_params.batch_axis = prim->batch_axis;
 
-        reverse_sequence_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
+        reverse_sequence_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
 
         auto& kernel_selector = kernel_selector::reverse_sequence_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(reverse_sequence_params, reverse_sequence_optional_params);
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 19b574383cebda..d97e999350fb11 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
@@ -55,11 +55,11 @@ struct roi_align_impl : typed_primitive_impl_ocl<roi_align> {
     }
 
 public:
-    static primitive_impl* create(const roi_align_node& arg) {
-        const auto& input_layout = arg.input().get_output_layout();
-        const auto& output_layout = arg.get_output_layout();
-        const auto& rois_layout = arg.input(1).get_output_layout();
-        const auto& batches_layout = arg.input(2).get_output_layout();
+    static primitive_impl* create(const roi_align_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& input_layout = impl_param->input_layouts[0];
+        const auto& output_layout = impl_param->output_layout;
+        const auto& rois_layout = impl_param->input_layouts[1];
+        const auto& batches_layout = impl_param->input_layouts[2];
         const auto& primitive = arg.get_primitive();
 
         const auto padding_filling_value = output_layout.data_padding.filling_value();
@@ -75,8 +75,7 @@ struct roi_align_impl : typed_primitive_impl_ocl<roi_align> {
                                       input_layout.format.value,
                                       "output_layout.format",
                                       output_layout.format);
-
-        auto roi_align_params = get_default_params<kernel_selector::roi_align_params>(arg);
+        auto roi_align_params = get_default_params<kernel_selector::roi_align_params>(*impl_param);
         auto roi_align_optional_params =
             get_default_optional_params<kernel_selector::roi_align_optional_params>(arg.get_program());
 
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 3eda85eb2f1546..3c5b42b5bf52ec 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
@@ -59,10 +59,10 @@ struct roi_pooling_impl : typed_primitive_impl_ocl<roi_pooling> {
     }
 
 public:
-    static primitive_impl* create(const roi_pooling_node& arg) {
-        const auto& input_layout = arg.input().get_output_layout();
-        const auto& output_layout = arg.get_output_layout();
-        const auto& rois_layout = arg.rois().get_output_layout();
+    static primitive_impl* create(const roi_pooling_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& input_layout = impl_param->input_layouts[0];
+        const auto& output_layout = impl_param->output_layout;
+        const auto& rois_layout = impl_param->input_layouts[1];
         const auto& primitive = arg.get_primitive();
 
         const auto padding_filling_value = output_layout.data_padding.filling_value();
@@ -78,8 +78,7 @@ struct roi_pooling_impl : typed_primitive_impl_ocl<roi_pooling> {
                                       input_layout.format.value,
                                       "output_layout.format",
                                       output_layout.format);
-
-        auto roi_params = get_default_params<kernel_selector::roi_pooling_params>(arg);
+        auto roi_params = get_default_params<kernel_selector::roi_pooling_params>(*impl_param);
         auto roi_optional_params =
             get_default_optional_params<kernel_selector::roi_pooling_optional_params>(arg.get_program());
 
@@ -87,7 +86,7 @@ struct roi_pooling_impl : typed_primitive_impl_ocl<roi_pooling> {
         const auto roi_bf = roi_bfyx.FlattenFeatureAndSpatials();
         roi_params.inputs.push_back(roi_bf);
         if (primitive->mode == pooling_mode::deformable_bilinear && !primitive->no_trans)
-            roi_params.inputs.push_back(convert_data_tensor(arg.trans().get_output_layout()));
+            roi_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
         roi_params.mode = cldnn_2_pool_type(primitive->mode);
         roi_params.position_sensitive = primitive->position_sensitive;
         roi_params.pooled_width = primitive->pooled_width;
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 113d9fe1535baa..0e0a3e79b2566f 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/roll.cpp
@@ -24,8 +24,8 @@ struct roll_impl : typed_primitive_impl_ocl<roll> {
         return make_unique<roll_impl>(*this);
     }
 
-    static primitive_impl* create(const roll_node& arg) {
-        auto roll_params = get_default_params<kernel_selector::roll_params>(arg);
+    static primitive_impl* create(const roll_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto roll_params = get_default_params<kernel_selector::roll_params>(*impl_param);
         auto roll_optional_params =
             get_default_optional_params<kernel_selector::roll_optional_params>(arg.get_program());
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scale.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scale.cpp
index f20019a6de9db7..2556ac7496328d 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/scale.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/scale.cpp
@@ -36,19 +36,19 @@ struct scale_impl : typed_primitive_impl_ocl<scale> {
     }
 
 public:
-    static primitive_impl* create(const scale_node& arg) {
-        auto ew_params = get_default_params<kernel_selector::eltwise_params>(arg);
+    static primitive_impl* create(const scale_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto ew_params = get_default_params<kernel_selector::eltwise_params>(*impl_param);
         auto ew_optional_params =
             get_default_optional_params<kernel_selector::eltwise_optional_params>(arg.get_program());
 
-        ew_params.inputs.push_back(convert_data_tensor(arg.scale_in().get_output_layout()));
+        ew_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
 
         ew_params.operations.push_back({{kernel_selector::eltwise_params::InputType::Buffer(0),
                                          kernel_selector::eltwise_params::InputType::Buffer(1)},
                                         kernel_selector::eltwise_mode::MUL});
 
         if (arg.bias_term()) {
-            ew_params.inputs.push_back(convert_data_tensor(arg.bias().get_output_layout()));
+            ew_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
             ew_params.operations.push_back({{kernel_selector::eltwise_params::InputType::Intermediate(0),
                                              kernel_selector::eltwise_params::InputType::Buffer(2)},
                                             kernel_selector::eltwise_mode::ADD});
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 2b080a27928130..cadd1fc5edb3e9 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
@@ -43,15 +43,16 @@ struct scatter_elements_update_impl : typed_primitive_impl_ocl<scatter_elements_
     }
 
 public:
-    static primitive_impl* create(const scatter_elements_update_node& arg) {
-        auto scatter_elements_update_params = get_default_params<kernel_selector::scatter_elements_update_params>(arg);
+    static primitive_impl* create(const scatter_elements_update_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto scatter_elements_update_params = get_default_params<kernel_selector::scatter_elements_update_params>(*impl_param);
         auto scatter_elements_update_optional_params =
             get_default_optional_params<kernel_selector::scatter_elements_update_optional_params>(arg.get_program());
 
-        scatter_elements_update_params.axis = convert_axis(arg.get_primitive()->axis, arg);
+        scatter_elements_update_params.axis = convert_axis(prim->axis, arg);
 
-        scatter_elements_update_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
-        scatter_elements_update_params.inputs.push_back(convert_data_tensor(arg.input(2).get_output_layout()));
+        scatter_elements_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
+        scatter_elements_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
 
         auto& kernel_selector = kernel_selector::scatter_elements_update_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(scatter_elements_update_params, scatter_elements_update_optional_params);
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 912358211ce484..ce95ac3c87f35b 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
@@ -24,15 +24,15 @@ struct scatter_nd_update_impl : typed_primitive_impl_ocl<scatter_nd_update> {
     }
 
 public:
-    static primitive_impl* create(const scatter_nd_update_node& arg) {
-        auto scatter_nd_update_params = get_default_params<kernel_selector::scatter_nd_update_params>(arg);
+    static primitive_impl* create(const scatter_nd_update_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto scatter_nd_update_params = get_default_params<kernel_selector::scatter_nd_update_params>(*impl_param);
         auto scatter_nd_update_optional_params =
             get_default_optional_params<kernel_selector::scatter_nd_update_optional_params>(arg.get_program());
 
         scatter_nd_update_params.indices_rank = arg.get_primitive()->indices_rank;
 
-        scatter_nd_update_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
-        scatter_nd_update_params.inputs.push_back(convert_data_tensor(arg.input(2).get_output_layout()));
+        scatter_nd_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
+        scatter_nd_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
 
         auto& kernel_selector = kernel_selector::scatter_nd_update_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(scatter_nd_update_params, scatter_nd_update_optional_params);
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 b563720edd7b48..bb6cf69246de38 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
@@ -43,15 +43,15 @@ struct scatter_update_impl : typed_primitive_impl_ocl<scatter_update> {
     }
 
 public:
-    static primitive_impl* create(const scatter_update_node& arg) {
-        auto scatter_update_params = get_default_params<kernel_selector::scatter_update_params>(arg);
+    static primitive_impl* create(const scatter_update_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto scatter_update_params = get_default_params<kernel_selector::scatter_update_params>(*impl_param);
         auto scatter_update_optional_params =
             get_default_optional_params<kernel_selector::scatter_update_optional_params>(arg.get_program());
 
         scatter_update_params.axis = convert_axis(arg.get_primitive()->axis, arg);
 
-        scatter_update_params.inputs.push_back(convert_data_tensor(arg.input(1).get_output_layout()));
-        scatter_update_params.inputs.push_back(convert_data_tensor(arg.input(2).get_output_layout()));
+        scatter_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[1]));
+        scatter_update_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[2]));
 
         auto& kernel_selector = kernel_selector::scatter_update_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(scatter_update_params, scatter_update_optional_params);
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 e376a0f46a63b1..8dd504336f6ac3 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/select.cpp
@@ -22,13 +22,13 @@ struct select_impl : typed_primitive_impl_ocl<select> {
     }
 
 public:
-    static primitive_impl* create(const select_node& arg) {
-        auto select_params = get_default_params<kernel_selector::select_params>(arg);
+    static primitive_impl* create(const select_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto select_params = get_default_params<kernel_selector::select_params>(*impl_param);
         auto select_optional_params =
             get_default_optional_params<kernel_selector::select_optional_params>(arg.get_program());
 
         for (size_t i = 1; i < arg.inputs_count(); i++) {
-            select_params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
+            select_params.inputs.push_back(convert_data_tensor(impl_param->input_layouts[i]));
         }
 
         auto& kernel_selector = kernel_selector::select_kernel_selector::Instance();
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 a277bad319c023..f2834d6d652835 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
@@ -21,13 +21,14 @@ struct shape_of_impl : typed_primitive_impl_ocl<shape_of> {
         return make_unique<shape_of_impl>(*this);
     }
 
-    static primitive_impl* create(const shape_of_node& arg) {
-        auto shape_of_params = get_default_params<kernel_selector::shape_of_params>(arg);
+    static primitive_impl* create(const shape_of_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto shape_of_params = get_default_params<kernel_selector::shape_of_params>(*impl_param);
         auto shape_of_optional_params =
             get_default_optional_params<kernel_selector::shape_of_optional_params>(arg.get_program());
 
-        shape_of_params.input_rank = arg.get_dependency(0).get_output_layout().get_rank();
-        shape_of_params.input_dims = arg.get_dependency(0).get_output_layout().get_dims();
+        auto input_layout = impl_param->input_layouts[0];
+        shape_of_params.input_rank = input_layout.get_rank();
+        shape_of_params.input_dims = input_layout.get_dims();
 
         auto& kernel_selector = kernel_selector::shape_of_instance();
         auto best_kernels = kernel_selector.GetBestKernels(shape_of_params, shape_of_optional_params);
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 1a769ff25b3542..f98ffbdedeba4c 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
@@ -24,18 +24,19 @@ struct shuffle_channels_impl : typed_primitive_impl_ocl<shuffle_channels> {
     }
 
 public:
-    static primitive_impl* create(const shuffle_channels_node& arg) {
-        auto shuffle_channels_params = get_default_params<kernel_selector::shuffle_channels_params>(arg);
+    static primitive_impl* create(const shuffle_channels_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto shuffle_channels_params = get_default_params<kernel_selector::shuffle_channels_params>(*impl_param);
         auto shuffle_channels_optional_params =
             get_default_optional_params<kernel_selector::shuffle_channels_optional_params>(arg.get_program());
 
         const int32_t number_of_dims = 4;
-        int32_t axis = arg.get_primitive()->axis;
+        int32_t axis = prim->axis;
 
         if (axis < 0)
             axis += number_of_dims;
 
-        shuffle_channels_params.group = arg.get_primitive()->group;
+        shuffle_channels_params.group = prim->group;
         shuffle_channels_params.axis = axis;
 
         auto& kernel_selector = kernel_selector::shuffle_channels_kernel_selector::Instance();
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 47336f51a5d95c..6a3e9ae1deb078 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp
@@ -70,12 +70,9 @@ struct slice_impl : typed_primitive_impl_ocl<slice> {
         return make_unique<slice_impl>(*this);
     }
 
-    static primitive_impl* create(const slice_node& arg) {
-        auto params = get_default_params<kernel_selector::slice_params>(
-                arg);
-        auto op_params = get_default_optional_params<
-                kernel_selector::slice_optional_params>(
-                arg.get_program());
+    static primitive_impl* create(const slice_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto params = get_default_params<kernel_selector::slice_params>(*impl_param);
+        auto op_params = get_default_optional_params<kernel_selector::slice_optional_params>(arg.get_program());
         const auto& inputs = arg.get_dependencies();
         const stream& stream = arg.get_program().get_stream();
         auto start_elts = extractIntegerData(inputs[InputIndices::kStart]->as<data>(), stream);
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 c2f5372d678929..76b1edff0e89fd 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/softmax.cpp
@@ -43,13 +43,12 @@ struct softmax_impl : typed_primitive_impl_ocl<softmax> {
         return make_unique<softmax_impl>(*this);
     }
 
-    static primitive_impl* create(const softmax_node& arg) {
-        auto sm_params = get_default_params<kernel_selector::softmax_params>(arg);
+    static primitive_impl* create(const softmax_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto primitive = arg.get_primitive();
+        auto sm_params = get_default_params<kernel_selector::softmax_params>(*impl_param);
         auto sm_optional_params =
             get_default_optional_params<kernel_selector::softmax_optional_params>(arg.get_program());
 
-        const auto primitive = arg.get_primitive();
-
         size_t rank = arg.get_output_layout().get_rank();
         sm_params.dim = GetSoftmaxDim(primitive->dimension, rank);
 
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 986ce4ff4dffb8..fa79d91dade721 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
@@ -25,13 +25,12 @@ struct space_to_batch_impl : typed_primitive_impl_ocl<space_to_batch> {
     }
 
 public:
-    static primitive_impl* create(const space_to_batch_node& arg) {
-        auto space_to_batch_params = get_default_params<kernel_selector::space_to_batch_params>(arg);
+    static primitive_impl* create(const space_to_batch_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto primitive = arg.get_primitive();
+        auto space_to_batch_params = get_default_params<kernel_selector::space_to_batch_params>(*impl_param);
         auto space_to_batch_optional_params =
             get_default_optional_params<kernel_selector::space_to_batch_optional_params>(arg.get_program());
 
-        auto primitive = arg.get_primitive();
-
         space_to_batch_params.block_shape = convert_dim_vector(primitive->block_shape);
         space_to_batch_params.pads_begin = convert_dim_vector(primitive->pads_begin);
         space_to_batch_params.pads_end = convert_dim_vector(primitive->pads_end);
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 dfebed1dc3a7e2..274f96238e05ce 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
@@ -23,16 +23,17 @@ struct space_to_depth_impl : typed_primitive_impl_ocl<space_to_depth> {
     }
 
 public:
-    static primitive_impl* create(const space_to_depth_node& arg) {
-        auto space_to_depth_params = get_default_params<kernel_selector::space_to_depth_params>(arg);
+    static primitive_impl* create(const space_to_depth_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto space_to_depth_params = get_default_params<kernel_selector::space_to_depth_params>(*impl_param);
         auto space_to_depth_optional_params =
                 get_default_optional_params<kernel_selector::space_to_depth_optional_params>(arg.get_program());
 
-        space_to_depth_params.depth_mode = (arg.get_primitive()->mode == space_to_depth::blocks_first) ?
+        space_to_depth_params.depth_mode = (prim->mode == space_to_depth::blocks_first) ?
                                            kernel_selector::SpaceToDepthMode::BLOCKS_FIRST :
                                            kernel_selector::SpaceToDepthMode::DEPTH_FIRST;
 
-        space_to_depth_params.block_size = arg.get_primitive()->block_size;
+        space_to_depth_params.block_size = prim->block_size;
 
         auto& kernel_selector = kernel_selector::space_to_depth_kernel_selector::Instance();
         auto best_kernels = kernel_selector.GetBestKernels(space_to_depth_params, space_to_depth_optional_params);
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 9e8aea479eb2e8..1a80adaa11e215 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
@@ -26,8 +26,9 @@ struct strided_slice_impl : typed_primitive_impl_ocl<strided_slice> {
     }
 
 public:
-    static primitive_impl* create(const strided_slice_node& arg) {
-        auto params = get_default_params<kernel_selector::strided_slice_params>(arg);
+    static primitive_impl* create(const strided_slice_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        const auto& prim = arg.get_primitive();
+        auto params = get_default_params<kernel_selector::strided_slice_params>(*impl_param);
         auto op_params = get_default_optional_params<kernel_selector::strided_slice_optional_params>(arg.get_program());
         const size_t dims_num = params.inputs[0].Dimentions();
 
@@ -52,10 +53,10 @@ struct strided_slice_impl : typed_primitive_impl_ocl<strided_slice> {
             params.striding_params.push_back(sizes);
         }
 
-        auto begin_mask_ = arg.get_primitive()->begin_mask;
-        auto end_mask_ = arg.get_primitive()->end_mask;
-        auto new_axis_mask_ = arg.get_primitive()->new_axis_mask;
-        auto shrink_axis_mask_ = arg.get_primitive()->shrink_axis_mask;
+        auto begin_mask_ = prim->begin_mask;
+        auto end_mask_ = prim->end_mask;
+        auto new_axis_mask_ = prim->new_axis_mask;
+        auto shrink_axis_mask_ = prim->shrink_axis_mask;
 
         std::vector<uint8_t> begin_mask(begin_mask_.begin(), begin_mask_.end());
         std::vector<uint8_t> end_mask(end_mask_.begin(), end_mask_.end());
@@ -72,6 +73,7 @@ struct strided_slice_impl : typed_primitive_impl_ocl<strided_slice> {
         pad_vector_to_size(params.end_mask, dims_num, 1);
         params.begin_mask = begin_mask;
         pad_vector_to_size(params.begin_mask, dims_num, 1);
+
         params.new_axis_mask = new_axis_mask;
         params.shrink_axis_mask = shrink_axis_mask;
         pad_vector_to_size(params.shrink_axis_mask, dims_num, 0);
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 6072b9d2ae9f26..14d6fa0f1bed14 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/tile.cpp
@@ -24,8 +24,8 @@ struct tile_impl : typed_primitive_impl_ocl<tile> {
     }
 
 public:
-    static primitive_impl* create(const tile_node& arg) {
-        auto tile_params = get_default_params<kernel_selector::tile_params>(arg);
+    static primitive_impl* create(const tile_node& arg, std::shared_ptr<kernel_impl_params> impl_param) {
+        auto tile_params = get_default_params<kernel_selector::tile_params>(*impl_param);
         auto tile_optional_params =
             get_default_optional_params<kernel_selector::tile_optional_params>(arg.get_program());
 
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 c1c4e6b915b351..998381dcc121b1 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
@@ -62,7 +62,7 @@ struct concatenation_onednn : typed_primitive_onednn_impl<concatenation, void, d
     }
 
 public:
-    static primitive_impl* create(const concatenation_node& arg) {
+    static primitive_impl* create(const concatenation_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto desc = get_concatenation_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
 
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 139d7af63678c8..96033658edbc72 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
@@ -158,7 +158,20 @@ struct convolution_onednn : typed_primitive_onednn_impl<convolution, dnnl::convo
         cldnn::format out_fmt = onednn::find_format(pd.weights_desc(0), grouped_weights);
         kernel_selector::WeightsLayout reqLayout = to_weights_layout(out_fmt, cldnn_prim->grouped_weights_shape);
 
-        set_params(arg, r_params);
+        const auto& param_info = kernel_impl_params(arg.get_program(), cldnn_prim, arg.get_unique_id(),
+                                                    arg.get_input_layouts(), arg.get_output_layout(),
+                                                    arg.get_fused_primitives(),
+                                                    arg.get_fused_activations_funcs(), arg.get_fused_activations_params(),
+                                                    optional_layout(weights_layout),
+                                                    arg.bias_term() ? optional_layout(arg.bias().get_output_layout()) : optional_layout(),
+                                                    arg.weights_zero_points_term() ? optional_layout(arg.weights_zero_points().get_output_layout())
+                                                        : optional_layout(),
+                                                    arg.activations_zero_points_term() ? optional_layout(arg.activations_zero_points().get_output_layout())
+                                                        : optional_layout(),
+                                                    arg.compensation_term() ? optional_layout(arg.compensation().get_output_layout())
+                                                        : optional_layout());
+
+        set_params(param_info, r_params);
         r_params.layerID = arg.id() + "_reorder_";
         r_params.input = convert_weights_tensor(weights_layout, cldnn_prim->grouped_weights_shape);
         r_params.output = r_params.input.TransformIgnorePadding(reqLayout, r_params.input.GetDType(), arg.get_groups(), false);
@@ -234,7 +247,7 @@ struct convolution_onednn : typed_primitive_onednn_impl<convolution, dnnl::convo
     }
 
 public:
-    static primitive_impl* create(const convolution_node& arg) {
+    static primitive_impl* create(const convolution_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_convolution_descriptor(arg);
         auto attr = get_primitive_attributes(arg);
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 88fb66752d8e71..82f08a0c94d2af 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
@@ -78,7 +78,14 @@ struct deconvolution_onednn : typed_primitive_onednn_impl<deconvolution, dnnl::d
         cldnn::format out_fmt = onednn::find_format(pd.weights_desc(0), grouped_weights);
         kernel_selector::WeightsLayout reqLayout = to_weights_layout(out_fmt, cldnn_prim->grouped_weights_shape);
 
-        set_params(arg, r_params);
+        const auto& param_info = kernel_impl_params(arg.get_program(), cldnn_prim, arg.get_unique_id(),
+                                                    arg.get_input_layouts(), arg.get_output_layout(),
+                                                    arg.get_fused_primitives(),
+                                                    arg.get_fused_activations_funcs(), arg.get_fused_activations_params(),
+                                                    optional_layout(weights_layout),
+                                                    arg.bias_term() ? optional_layout(arg.bias().get_output_layout()) : optional_layout());
+
+        set_params(param_info, r_params);
         r_params.layerID = arg.id() + "_reorder_";
         r_params.input = convert_weights_tensor(weights_layout, cldnn_prim->grouped_weights_shape);
         r_params.output = r_params.input.TransformIgnorePadding(reqLayout, r_params.input.GetDType(), arg.get_groups(), false);
@@ -154,7 +161,7 @@ struct deconvolution_onednn : typed_primitive_onednn_impl<deconvolution, dnnl::d
     }
 
 public:
-    static primitive_impl* create(const deconvolution_node& arg) {
+    static primitive_impl* create(const deconvolution_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_deconvolution_descriptor(arg);
         auto attr = get_primitive_attributes(arg);
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 8a482b762fa6cb..fd97be699cc4db 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
@@ -58,17 +58,24 @@ struct fully_connected_onednn : typed_primitive_onednn_impl<fully_connected, dnn
     }
 
     static kernel_selector::WeightsReorderParams get_weights_reorder(const fully_connected_node& arg, const dnnl::primitive_desc& pd) {
+        auto weights_layout = arg.get_dependency(1).get_output_layout();
+        auto cldnn_prim = arg.get_primitive();
+        const auto& param_info = kernel_impl_params(arg.get_program(), cldnn_prim, arg.get_unique_id(),
+                                                    arg.get_input_layouts(), arg.get_output_layout(),
+                                                    arg.get_fused_primitives(),
+                                                    arg.get_fused_activations_funcs(), arg.get_fused_activations_params(),
+                                                    optional_layout(weights_layout),
+                                                    arg.bias_term() ? optional_layout(arg.bias().get_output_layout()) : optional_layout());
+
         kernel_selector::WeightsReorderParams weights_reorder_params;
         auto& reorderKS = kernel_selector::ReorderWeightsKernelSelctor::Instance();
         kernel_selector::reorder_weights_params r_params;
 
-        auto cldnn_prim = arg.get_primitive();
-        auto weights_layout = arg.get_dependency(1).get_output_layout();
         cldnn::format out_fmt = onednn::find_format(pd.weights_desc(0));
         kernel_selector::WeightsLayout req_layout = to_weights_layout(out_fmt, false);
 
         // set engine info & forcing
-        set_params(arg, r_params);
+        set_params(param_info, r_params);
         r_params.layerID = arg.id() + "_reorder_";
         r_params.input = convert_weights_tensor(weights_layout, false);
         r_params.output = r_params.input.TransformIgnorePadding(req_layout, r_params.input.GetDType(), 1, false);
@@ -125,7 +132,7 @@ struct fully_connected_onednn : typed_primitive_onednn_impl<fully_connected, dnn
     }
 
 public:
-    static primitive_impl* create(const fully_connected_node& arg) {
+    static primitive_impl* create(const fully_connected_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_fully_connected_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
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 22ad4f63cdda98..bf3b8319780811 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
@@ -123,7 +123,7 @@ struct gemm_onednn : typed_primitive_onednn_impl<gemm, dnnl::matmul::desc> {
     }
 
 public:
-    static primitive_impl* create(const gemm_node& arg) {
+    static primitive_impl* create(const gemm_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_gemm_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
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 13fd4858962a12..e312b9dcff1963 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
@@ -66,7 +66,7 @@ struct pooling_onednn : typed_primitive_onednn_impl<pooling, dnnl::pooling_forwa
     }
 
 public:
-    static primitive_impl* create(const pooling_node& arg) {
+    static primitive_impl* create(const pooling_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_pooling_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
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 776943567734e9..79ccc00a99caf0 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
@@ -63,7 +63,7 @@ struct reduction_onednn : typed_primitive_onednn_impl<reduce, dnnl::reduction::d
     }
 
 public:
-    static primitive_impl* create(const reduce_node& arg) {
+    static primitive_impl* create(const reduce_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto& engine = arg.get_program().get_engine();
         auto desc = get_reduction_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
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 08e330e9a9e2d6..5f656607dff4d6 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
@@ -59,7 +59,7 @@ struct reorder_onednn : typed_primitive_onednn_impl<reorder, void, dnnl::reorder
     }
 
 public:
-    static primitive_impl* create(const reorder_node& arg) {
+    static primitive_impl* create(const reorder_node& arg, std::shared_ptr<kernel_impl_params>) {
         auto desc = get_reorder_descriptor(arg);
         auto attr = arg.get_onednn_primitive_attributes();
 
diff --git a/src/plugins/intel_gpu/src/graph/include/binary_convolution_inst.h b/src/plugins/intel_gpu/src/graph/include/binary_convolution_inst.h
index 0426acd06162fe..74bd01aabbff5d 100644
--- a/src/plugins/intel_gpu/src/graph/include/binary_convolution_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/binary_convolution_inst.h
@@ -41,7 +41,13 @@ struct typed_program_node<binary_convolution> : public typed_program_node_base<b
         throw std::runtime_error("bias should not be used in binary convolution");
     }
 
-    bool bias_term() const { return false; }
+    std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                              const layout& out_layout) const override {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(),
+                                  in_layouts, out_layout,
+                                  get_fused_primitives(), get_fused_activations_funcs(), get_fused_activations_params(),
+                                  optional_layout(weights().get_output_layout())));
+    }
 
 private:
     int32_t split;
diff --git a/src/plugins/intel_gpu/src/graph/include/convolution_inst.h b/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
index fd2ac64715ef92..bd0a707b4c9f83 100644
--- a/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/convolution_inst.h
@@ -115,11 +115,22 @@ struct typed_program_node<convolution> : public typed_program_node_base<convolut
     }
 
     bool bias_term() const { return get_primitive()->bias.size() > 0; }
-
     bool weights_zero_points_term() const { return get_primitive()->weights_zero_points.size() > 0; }
     bool compensation_term() const { return get_primitive()->compensation.size() > 0; }
     bool activations_zero_points_term() const { return get_primitive()->activations_zero_points.size() > 0; }
 
+    std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                              const layout& out_layout) const override {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(),
+                                  in_layouts, out_layout,
+                                  get_fused_primitives(), get_fused_activations_funcs(), get_fused_activations_params(),
+                                  optional_layout(weights().get_output_layout()),
+                                  bias_term() ? optional_layout(bias().get_output_layout()) : optional_layout(),
+                                  weights_zero_points_term() ? optional_layout(weights_zero_points().get_output_layout()) : optional_layout(),
+                                  activations_zero_points_term() ? optional_layout(activations_zero_points().get_output_layout()) : optional_layout(),
+                                  compensation_term() ? optional_layout(compensation().get_output_layout()) : optional_layout()));
+    }
+
 private:
     int32_t split;
     bool depthwise_sep_opt;
diff --git a/src/plugins/intel_gpu/src/graph/include/deconvolution_inst.h b/src/plugins/intel_gpu/src/graph/include/deconvolution_inst.h
index 08df5cce4c874c..0db39a40e57d6a 100644
--- a/src/plugins/intel_gpu/src/graph/include/deconvolution_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/deconvolution_inst.h
@@ -73,6 +73,15 @@ struct typed_program_node<deconvolution> : public typed_program_node_base<deconv
         return dependencies.size() == (d_idx + 1);
     }
 
+    std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                              const layout& out_layout) const override {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(),
+                                  in_layouts, out_layout,
+                                  get_fused_primitives(), get_fused_activations_funcs(), get_fused_activations_params(),
+                                  optional_layout(weights().get_output_layout()),
+                                  bias_term() ? optional_layout(bias().get_output_layout()) : optional_layout()));
+    }
+
 private:
     int32_t split;
     bool depthwise_sep_opt;
diff --git a/src/plugins/intel_gpu/src/graph/include/deformable_convolution_inst.h b/src/plugins/intel_gpu/src/graph/include/deformable_convolution_inst.h
index 7ec741ca35b35c..14a4a858c16ed6 100644
--- a/src/plugins/intel_gpu/src/graph/include/deformable_convolution_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/deformable_convolution_inst.h
@@ -56,6 +56,15 @@ struct typed_program_node<deformable_conv> : public typed_program_node_base<defo
 
     bool bias_term() const { return get_primitive()->bias.size() > 0; }
 
+    std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                              const layout& out_layout) const override {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(),
+                                  in_layouts, out_layout,
+                                  get_fused_primitives(), get_fused_activations_funcs(), get_fused_activations_params(),
+                                  optional_layout(weights().get_output_layout()),
+                                  bias_term() ? optional_layout(bias().get_output_layout()) : optional_layout()));
+    }
+
 private:
     int32_t split;
     bool depthwise_sep_opt;
diff --git a/src/plugins/intel_gpu/src/graph/include/fully_connected_inst.h b/src/plugins/intel_gpu/src/graph/include/fully_connected_inst.h
index dc6d1dd7729c40..fe905fd79f6d3b 100644
--- a/src/plugins/intel_gpu/src/graph/include/fully_connected_inst.h
+++ b/src/plugins/intel_gpu/src/graph/include/fully_connected_inst.h
@@ -23,6 +23,14 @@ struct typed_program_node<fully_connected> : public typed_program_node_base<full
     program_node& weights() const { return get_dependency(1); }
     program_node& bias() const { return get_dependency(2); }
     bool bias_term() const { return !get_primitive()->bias.empty(); }
+    std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                              const layout& out_layout) const override {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(),
+                                  in_layouts, out_layout,
+                                  get_fused_primitives(), get_fused_activations_funcs(), get_fused_activations_params(),
+                                  optional_layout(weights().get_output_layout()),
+                                  bias_term() ? optional_layout(bias().get_output_layout()) : optional_layout()));
+    }
 };
 
 using fully_connected_node = typed_program_node<fully_connected>;
diff --git a/src/plugins/intel_gpu/src/graph/include/fused_primitive_desc.h b/src/plugins/intel_gpu/src/graph/include/fused_primitive_desc.h
new file mode 100644
index 00000000000000..aa0061cef92b22
--- /dev/null
+++ b/src/plugins/intel_gpu/src/graph/include/fused_primitive_desc.h
@@ -0,0 +1,49 @@
+// Copyright (C) 2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "intel_gpu/primitives/primitive.hpp"
+#include "intel_gpu/primitives/activation.hpp"
+#include "kernel_selector_params.h"
+#include "meta_utils.h"
+
+namespace cldnn {
+struct fused_primitive_desc {
+    explicit fused_primitive_desc(std::shared_ptr<const primitive> prim) : desc(prim) {}
+
+    template <class PType>
+    bool is_type() const {
+        static_assert(meta::is_primitive<PType>::value,
+            "Type argument fused_primitive_desc::is_type should be a non-const, non-volatile type derived from primitive");
+        return desc->type == PType::type_id();
+    }
+
+    template <class PType>
+    std::shared_ptr<const PType> typed_desc() const { return std::static_pointer_cast<const PType>(desc); }
+
+    template<typename T>
+    std::shared_ptr<T> get_typed_fuse_params() const {
+        auto p = std::dynamic_pointer_cast<T>(f_param);
+        if (!p)
+            throw std::runtime_error("Invalid dynamic cast of fused parameters!");
+        return p;
+    }
+
+    std::shared_ptr<const primitive> desc;
+
+    layout input_layout = layout(data_types::f32, format::bfyx, tensor());
+    layout output_layout = layout(data_types::f32, format::bfyx, tensor());
+
+    std::shared_ptr<kernel_selector::fuse_params> f_param;
+
+    std::vector<std::pair<primitive_id, size_t>> deps;
+    std::map<primitive_id, size_t> fused_deps;
+    size_t dep_start_idx;
+    size_t total_num_deps = 0;
+
+    activation_func activation;
+    activation_additional_params activation_params = { 0.f, 0.f };
+};
+} // namespace cldnn
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 a2fc92779a8fe7..65e5c6cc5a703c 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/runtime/engine.hpp"
 #include "intel_gpu/runtime/utils.hpp"
 #include "intel_gpu/runtime/tensor.hpp"
 #include "intel_gpu/runtime/error_handler.hpp"
@@ -11,10 +12,12 @@
 #include "intel_gpu/primitives/scale.hpp"
 #include "intel_gpu/primitives/quantize.hpp"
 #include "intel_gpu/primitives/activation.hpp"
+#include "intel_gpu/primitives/primitive.hpp"
 
 #include "kernel_selector_params.h"
 #include "kernel_selector_common.h"
 #include "tensor_type.h"
+#include "fused_primitive_desc.h"
 
 #include <cstdint>
 #include <string>
@@ -29,7 +32,7 @@ enum class tuning_mode;
 struct format;
 struct layout;
 struct program;
-struct program_node;
+struct fused_primitive_desc;
 }  // namespace cldnn
 
 namespace kernel_selector {
@@ -44,7 +47,6 @@ using kernel_scalar_arguments = kernel_selector::Scalars;
 using kernel_scalar_argument_types = kernel_selector::ScalarDescriptor::Types;
 
 using data_type = kernel_selector::Datatype;
-using kernel_type = kernel_selector::KernelType;
 using weights_type = kernel_selector::WeightsType;
 using activation_function = kernel_selector::ActivationFunction;
 using pool_type = kernel_selector::PoolType;
@@ -106,6 +108,47 @@ kernel_selector::weights_tensor convert_weights_tensor(const layout& l, bool is_
 layout from_weights_tensor(const kernel_selector::weights_tensor& t);
 kernel_selector::activation_function get_kernel_selector_activation_param(activation_func activation_func);
 
+struct kernel_impl_params {
+    bool has_runtime_layouts = false;
+    const program& prog;
+    std::shared_ptr<const primitive> desc;
+    size_t unique_id;
+    std::vector<layout> input_layouts;
+    layout output_layout;
+    std::vector<cldnn::fused_primitive_desc> fused_desc;
+    std::vector<activation_func> fused_act_funcs;
+    std::vector<activation_additional_params> activation_params;
+
+    optional_layout weights_layout;
+
+    optional_layout bias_layout;
+    optional_layout weights_zero_points_layout;
+    optional_layout activations_zero_points_layout;
+    optional_layout compensation_layout;
+
+    kernel_impl_params(program& _prog, std::shared_ptr<const primitive> _desc, size_t _uid,
+                       const std::vector<layout>& _int_layouts, layout _out_layout,
+                       const std::vector<cldnn::fused_primitive_desc>& _fused_descs,
+                       const std::vector<activation_func>& _fused_act_funcs, const std::vector<activation_additional_params>& _act_params,
+                       optional_layout _weights_layout = optional_layout(),
+                       optional_layout _bias_layout = optional_layout(),
+                       optional_layout _weights_zero_points_layout = optional_layout(),
+                       optional_layout _activations_zero_points_layout = optional_layout(),
+                       optional_layout _compensation_layout = optional_layout())
+                       : has_runtime_layouts(true),
+                         prog(_prog), desc(_desc), unique_id(_uid),
+                         input_layouts(_int_layouts), output_layout(_out_layout),
+                         fused_desc(_fused_descs),
+                         fused_act_funcs(_fused_act_funcs), activation_params(_act_params),
+                         weights_layout(_weights_layout), bias_layout(_bias_layout),
+                         weights_zero_points_layout(_weights_zero_points_layout),
+                         activations_zero_points_layout(_activations_zero_points_layout),
+                         compensation_layout(_compensation_layout) {}
+
+    template <class PType>
+    std::shared_ptr<const PType> typed_desc() const { return std::static_pointer_cast<const PType>(desc); }
+};
+
 template <typename T = std::uint32_t>
 kernel_selector::dim_tensor<T> convert_dim_vector(const tensor& t) {
     const auto& sizes = t.sizes(format::bfwzyx);
@@ -127,15 +170,15 @@ inline void convert_activation_func_params(const p_type primitive, std::vector<k
     }
 }
 
-template <typename arg_t>
-inline void convert_fused_activation_func_params(const arg_t& arg, std::vector<kernel_selector::base_activation_params>& params) {
-    for (size_t i = 0; i < arg.get_fused_activations_funcs().size(); i++) {
-        params.emplace_back(get_kernel_selector_activation_param(arg.get_fused_activations_funcs()[i]),
-                            arg.get_fused_activations_params()[i].a,
-                            arg.get_fused_activations_params()[i].b);
+inline void convert_fused_activation_func_params(const kernel_impl_params& param_info, std::vector<kernel_selector::base_activation_params>& params) {
+    const auto& act_funcs = param_info.fused_act_funcs;
+    const auto& act_params = param_info.activation_params;
+    for (size_t i = 0; i < act_funcs.size(); i++) {
+        params.emplace_back(get_kernel_selector_activation_param(act_funcs[i]),
+                            act_params[i].a,
+                            act_params[i].b);
     }
 }
-
 template <typename p_type>
 inline void convert_new_activation_func(const p_type primitive, std::vector<kernel_selector::base_activation_params>& params) {
     params.insert(params.begin(), {get_kernel_selector_activation_param(primitive->activation_function),
@@ -143,41 +186,41 @@ inline void convert_new_activation_func(const p_type primitive, std::vector<kern
                                    primitive->additional_params.b});
 }
 
-void set_params(const program_node& node, kernel_selector::params& params);
+void set_params(const kernel_impl_params& param_info, kernel_selector::params& params);
 
-template <typename params_t, typename arg_t>
-inline params_t get_default_params(const arg_t& arg, uint32_t split = 1) {
+template <typename params_t>
+inline params_t get_default_params(const kernel_impl_params& param_info, uint32_t split = 1) {
     params_t params;
 
-    set_params(arg, params);
+    set_params(param_info, params);
 
-    const auto& input_layout = arg.input().get_output_layout();
-    const auto& output_layout = arg.get_output_layout();
+    const auto& input_layout = param_info.input_layouts[0];
+    const auto& output_layout = param_info.output_layout;
 
     params.inputs[0] = convert_data_tensor(input_layout, split);
     params.outputs[0] = convert_data_tensor(output_layout, split);
+    params.layerID = param_info.desc->id;
 
-    params.layerID = arg.id();
-
-    convert_fused_activation_func_params(arg, params.activations);
+    convert_fused_activation_func_params(param_info, params.activations);
     std::map<primitive_id, std::pair<size_t, kernel_selector::Datatype>> prim_id_type_map;
     size_t op_id = 0;
-    for (auto& fused_prim : arg.get_fused_primitives()) {
+    for (auto& fused_prim : param_info.fused_desc) {
         kernel_selector::fused_operation_desc desc;
-        desc.op_params = fused_prim.node->get_fuse_params();
+        desc.op_params = std::move(fused_prim.f_param);
+
         if (!desc.op_params) {
-            CLDNN_ERROR_MESSAGE(arg.id(), "Invalid fused operation (" + fused_prim.node->id() + ") of type " +
-                                           fused_prim.node->get_primitive()->type_string() );
+            CLDNN_ERROR_MESSAGE(param_info.desc->id, "Invalid fused operation (" + param_info.desc->id + ") of type " +
+                                           param_info.desc->type_string());
         }
 
         desc.dep_idx_start = fused_prim.dep_start_idx;
         desc.dep_size = fused_prim.deps.size();
         desc.op_id = op_id++;
         desc.output_tensor = convert_data_tensor(fused_prim.output_layout);
-        prim_id_type_map[fused_prim.node->id()] = std::make_pair(desc.op_id, desc.output_tensor.GetDType());
+        prim_id_type_map[fused_prim.desc->id] = std::make_pair(desc.op_id, desc.output_tensor.GetDType());
 
         for (size_t i = desc.dep_idx_start; i < desc.dep_idx_start + desc.dep_size; i++) {
-            desc.tensors.push_back(convert_data_tensor(arg.get_dependency(i).get_output_layout()));
+            desc.tensors.push_back(convert_data_tensor(param_info.input_layouts[i]));
         }
 
         if (fused_prim.total_num_deps > 0) {
@@ -208,19 +251,17 @@ inline params_t get_default_params(const arg_t& arg, uint32_t split = 1) {
         }
         params.fused_ops.push_back(desc);
     }
-
     return params;
 }
 
-template <typename params_t, typename arg_t>
-inline params_t get_weights_bias_default_params(const arg_t& arg, uint32_t split = 1, uint32_t groups = 1, bool has_group_dimension = false) {
-    params_t params = get_default_params<params_t>(arg, split);
-    const auto& weights_layout = arg.weights().get_output_layout();
-    params.weights = convert_weights_tensor(weights_layout, has_group_dimension);
+template <typename params_t>
+inline params_t get_weights_bias_default_params(const kernel_impl_params& param_info, uint32_t split = 1, uint32_t groups = 1,
+                                                bool has_group_dimension = false) {
+    params_t params = get_default_params<params_t>(param_info, split);
+    params.weights = convert_weights_tensor(*param_info.weights_layout, has_group_dimension);
 
-    if (arg.bias_term()) {
-        auto bias_layout = arg.bias().get_output_layout();
-        // bias per output is not supported on cldnn
+    if (param_info.bias_layout) {
+        auto bias_layout = *param_info.bias_layout;
         if (groups != 1) {
             auto bias_size = bias_layout.get_tensor();
             bias_size.feature[0] /= static_cast<int>(groups);
@@ -232,25 +273,26 @@ inline params_t get_weights_bias_default_params(const arg_t& arg, uint32_t split
     return params;
 }
 
-template <typename params_t, typename arg_t>
-params_t get_weight_bias_zero_point_default_params(const arg_t& arg, uint32_t split = 1, uint32_t groups = 1, bool has_group_dimension = false) {
-    params_t params = get_weights_bias_default_params<params_t>(arg, split, groups, has_group_dimension);
+template <typename params_t>
+params_t get_weight_bias_zero_point_default_params(const kernel_impl_params& param_info, uint32_t split = 1, uint32_t groups = 1,
+                                                   bool has_group_dimension = false) {
+    params_t params = get_weights_bias_default_params<params_t>(param_info, split, groups, has_group_dimension);
 
-    if (arg.weights_zero_points_term()) {
+    if (param_info.weights_zero_points_layout) {
         params.weights_zero_points.push_back(
-            convert_data_tensor(arg.weights_zero_points().get_output_layout())
+            convert_data_tensor(*param_info.weights_zero_points_layout)
             .FlattenFeatureAndSpatials());
     }
 
-    if (arg.activations_zero_points_term()) {
+    if (param_info.activations_zero_points_layout) {
         params.activations_zero_points.push_back(
-            convert_data_tensor(arg.activations_zero_points().get_output_layout())
+            convert_data_tensor(*param_info.activations_zero_points_layout)
             .FlattenFeatureAndSpatials());
     }
 
-    if (arg.compensation_term()) {
+    if (param_info.compensation_layout) {
         params.compensation.push_back(
-            convert_data_tensor(arg.compensation().get_output_layout()).FlattenFeatureAndSpatials());
+            convert_data_tensor(*param_info.compensation_layout).FlattenFeatureAndSpatials());
     }
 
     return params;
diff --git a/src/plugins/intel_gpu/src/graph/include/primitive_type.h b/src/plugins/intel_gpu/src/graph/include/primitive_type.h
index dd7c3d8efefced..61c5aca5bb130e 100644
--- a/src/plugins/intel_gpu/src/graph/include/primitive_type.h
+++ b/src/plugins/intel_gpu/src/graph/include/primitive_type.h
@@ -6,7 +6,7 @@
 #pragma once
 
 #include "intel_gpu/runtime/layout.hpp"
-
+#include "kernel_selector_helper.h"
 #include <memory>
 #include <string>
 
@@ -26,9 +26,16 @@ struct primitive_type {
                                                       const std::shared_ptr<primitive> prim) const = 0;
     virtual std::shared_ptr<primitive_inst> create_instance(network& network,
                                                             const program_node& node) const = 0;
+
     virtual std::unique_ptr<primitive_impl> choose_impl(const program_node& node) const = 0;
+    virtual std::unique_ptr<primitive_impl> choose_impl(const program_node& node, std::shared_ptr<kernel_impl_params> params) const = 0;
+
     virtual bool does_an_implementation_exist(const program_node& node) const = 0;
+    virtual bool does_an_implementation_exist(const program_node& node, std::shared_ptr<kernel_impl_params> params) const = 0;
+
     virtual bool does_possible_implementation_exist(const program_node& node) const = 0;
+    virtual bool does_possible_implementation_exist(const program_node& node, std::shared_ptr<kernel_impl_params> params) const = 0;
+
     virtual layout calc_output_layout(const program_node& node) const = 0;
     virtual std::string to_string(const program_node& node) const = 0;
 };
diff --git a/src/plugins/intel_gpu/src/graph/include/primitive_type_base.h b/src/plugins/intel_gpu/src/graph/include/primitive_type_base.h
index cb0ecf50ae6415..9d7c9ba5175b5b 100644
--- a/src/plugins/intel_gpu/src/graph/include/primitive_type_base.h
+++ b/src/plugins/intel_gpu/src/graph/include/primitive_type_base.h
@@ -38,24 +38,36 @@ struct primitive_type_base : primitive_type {
 
     // TODO: Should we get rid of engine type in impl map? Or we must pass internal build engine to get real ocl type?
     std::unique_ptr<primitive_impl> choose_impl(const cldnn::program_node& node) const override {
+        return choose_impl(node, node.get_kernel_impl_params());
+    }
+
+    std::unique_ptr<primitive_impl> choose_impl(const cldnn::program_node& node, std::shared_ptr<kernel_impl_params> runtime_params) const override {
         if (node.type() != this)
             throw std::invalid_argument("primitive_type_base::choose_impl: primitive type mismatch");
-
-        auto factory = implementation_map<PType>::get(node);
-        return std::move(std::unique_ptr<primitive_impl>(factory(node)));
+        auto factory = implementation_map<PType>::get(runtime_params, node.get_preferred_impl_type());
+        auto impl = std::unique_ptr<primitive_impl>(factory(node, runtime_params));
+        return impl;
     }
 
     bool does_an_implementation_exist(const cldnn::program_node& node) const override {
+        return does_an_implementation_exist(node, node.get_kernel_impl_params());
+    }
+
+    bool does_an_implementation_exist(const cldnn::program_node& node, std::shared_ptr<kernel_impl_params> impl_param) const override {
         if (node.type() != this)
             throw std::invalid_argument("primitive_type_base::does_an_implementation_exist: primitive type mismatch");
 
-        return implementation_map<PType>::check(node);
+        return implementation_map<PType>::check(node, impl_param);
     }
 
     bool does_possible_implementation_exist(const cldnn::program_node& node) const override {
+        return does_possible_implementation_exist(node, node.get_kernel_impl_params());
+    }
+
+    bool does_possible_implementation_exist(const cldnn::program_node& node, std::shared_ptr<kernel_impl_params> impl_param) const override {
         if (node.type() != this)
             throw std::invalid_argument("primitive_type_base::does_possible_implementation_exist: primitive type mismatch");
-        return implementation_map<PType>::check_io_eq(node);
+        return implementation_map<PType>::check_io_eq(node, impl_param);
     }
 
     cldnn::layout calc_output_layout(const cldnn::program_node& node) const override {
diff --git a/src/plugins/intel_gpu/src/graph/include/program_helpers.h b/src/plugins/intel_gpu/src/graph/include/program_helpers.h
index dee11d8d88f92a..fdce2d186d9e62 100644
--- a/src/plugins/intel_gpu/src/graph/include/program_helpers.h
+++ b/src/plugins/intel_gpu/src/graph/include/program_helpers.h
@@ -140,7 +140,7 @@ struct onednn_add_fusing_helpers {
     static bool is_full_tensor(const layout& layout);
     static std::vector<fused_primitive_desc> get_fused_eltwise_primitives();
     static void for_eltwise(const program_node& conv_node, eltwise_mode mode,
-                            std::function<void(const program_node&, const eltwise_node&, const fused_primitive_desc&)> func);
+                            std::function<void(const program_node&, const fused_primitive_desc&)> func);
     static add_fusing_type get_add_fusing_type(const program_node& node, const fused_primitive_desc& desc);
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/include/program_node.h b/src/plugins/intel_gpu/src/graph/include/program_node.h
index b6160dec5e1a42..64f13cd0c6d927 100644
--- a/src/plugins/intel_gpu/src/graph/include/program_node.h
+++ b/src/plugins/intel_gpu/src/graph/include/program_node.h
@@ -10,6 +10,7 @@
 #include "intel_gpu/graph/program.hpp"
 
 #include "kernel_selector_helper.h"
+#include "fused_primitive_desc.h"
 #include "meta_utils.h"
 
 #include <set>
@@ -87,18 +88,6 @@ struct fused_primitive_desc_onednn {
 };
 #endif // ENABLE_ONEDNN_FOR_GPU
 
-struct fused_primitive_desc {
-    std::shared_ptr<program_node> node;
-    size_t dep_start_idx;
-    std::vector<std::pair<primitive_id, size_t>> deps;
-    std::map<primitive_id, size_t> fused_deps;
-    size_t total_num_deps = 0;
-    activation_func activation;
-    activation_additional_params activation_params = { 0.f, 0.f };
-    layout input_layout = layout(data_types::f32, format::bfyx, tensor());
-    layout output_layout = layout(data_types::f32, format::bfyx, tensor());
-};
-
 /*
     Base class for all primitives which wraps API class and extends it to be used
     in graph context.
@@ -136,6 +125,17 @@ struct program_node {
     virtual primitive_type_id type() const { return desc->type; }
     virtual std::shared_ptr<kernel_selector::fuse_params> get_fuse_params() const { return nullptr; }
 
+    virtual std::unique_ptr<kernel_impl_params> get_kernel_impl_params() const {
+        return get_kernel_impl_params(get_input_layouts(), output_layout);
+    }
+
+    virtual std::unique_ptr<kernel_impl_params> get_kernel_impl_params(const std::vector<layout>& in_layouts,
+                                                      const layout& out_layout) const {
+        return std::unique_ptr<kernel_impl_params>(new kernel_impl_params(get_program(), get_primitive(), get_unique_id(), in_layouts, out_layout,
+                                  get_fused_primitives(),
+                                  get_fused_activations_funcs(), get_fused_activations_params()));
+    }
+
     const primitive_id& get_ext_prim_id() const { return desc->ext_prim_id; }
 
     template <class PType>
@@ -158,6 +158,14 @@ struct program_node {
     std::vector<program_node*> const& get_dependencies() const { return dependencies; }
     program_node& get_dependency(size_t idx) const { return *dependencies.at(idx); }
 
+    std::vector<layout> const get_input_layouts() const {
+        std::vector<layout> layouts;
+        for (const auto& i : dependencies) {
+            layouts.push_back(i->get_output_layout());
+        }
+        return layouts;
+    }
+
     // replaces idx-th dependency of 'this' with 'new_dep', calls program::remove_if_dangling(old_dep)
     void replace_dependency(size_t idx, program_node& new_dep, bool remove_if_dangling = true);
     // searches for 'old_dep' in dependencies list of 'this' and replaces it with 'new_dep', calls
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 978a67d0183a3f..71cceb90fddff5 100644
--- a/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp
+++ b/src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp
@@ -905,11 +905,11 @@ kernel_selector::activation_function get_kernel_selector_activation_param(activa
     }
 }
 
-void set_params(const program_node& node, kernel_selector::params& params) {
-    const auto& program = node.get_program();
+void set_params(const kernel_impl_params& param_info, kernel_selector::params& params) {
+    const auto& program = param_info.prog;
     const auto& device_info = program.get_engine().get_device_info();
 
-    params.uniqueID = std::to_string(node.get_unique_id());
+    params.uniqueID = std::to_string(param_info.unique_id);
     params.engineInfo.bSubGroupSupport = device_info.supports_subgroups;
     params.engineInfo.bSubGroupShortSupport = device_info.supports_subgroups_short;
     params.engineInfo.bSubGroupCharSupport = device_info.supports_subgroups_char;
@@ -935,8 +935,8 @@ void set_params(const program_node& node, kernel_selector::params& params) {
     auto impl_forcing_bo = program.get_options().get<build_option_type::force_implementations>();
     const auto& impl_forcing = impl_forcing_bo->forcing;
 
-    if (impl_forcing.count(node.id()) != 0) {
-        params.forceImplementation = impl_forcing.at(node.id()).kernel_name;
+    if (impl_forcing.count(param_info.desc->id) != 0) {
+        params.forceImplementation = impl_forcing.at(param_info.desc->id).kernel_name;
     }
 }
 
diff --git a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
index 788e29cfeebde2..7fa813bd16aa8c 100644
--- a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
+++ b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
@@ -34,21 +34,19 @@ using namespace cldnn;
 static size_t get_post_ops_count(const program_node& node) {
     size_t onednn_post_ops_count = 0;
     for (auto& fo : node.get_fused_primitives()) {
-        if (fo.node->is_type<activation>() || fo.node->is_type<eltwise>()) {
+        if (fo.is_type<activation>() || fo.is_type<eltwise>()) {
             onednn_post_ops_count++;
-        } else if (fo.node->is_type<quantize>()) {
-            auto& q = fo.node->as<quantize>();
-
+        } else if (fo.is_type<quantize>()) {
             // pre-scale, pre-shift
-            if (q.get_per_tensor_input_scale() && q.get_per_tensor_input_shift()) {
+            const auto& q_param = fo.get_typed_fuse_params<kernel_selector::quantize_fuse_params>();
+            if (q_param->per_tensor_input_scale && q_param->per_tensor_input_shift) {
                 onednn_post_ops_count++;
             } else {
                 onednn_post_ops_count += 2;
             }
 
             // post-scale, post-shift
-            if (q.get_need_post_scale() && q.get_need_post_shift() &&
-                q.get_per_tensor_output_scale() && q.get_per_tensor_output_shift()) {
+            if (q_param->has_post_scale && q_param->has_post_shift && q_param->per_tensor_output_scale && q_param->per_tensor_output_shift) {
                 onednn_post_ops_count++;
             } else {
                 onednn_post_ops_count += 2;
@@ -56,7 +54,7 @@ static size_t get_post_ops_count(const program_node& node) {
 
             auto out_dt = fo.output_layout.data_type;
             auto output_type_is_int8 = out_dt == data_types::u8 || out_dt == data_types::i8;
-            auto out_range_usage = q.get_per_tensor_output_range() && q.get_output_lo_val() < q.get_output_hi_val();
+            auto out_range_usage = q_param->per_tensor_output_range && (q_param->out_lo < q_param->out_hi);
 
             if (out_range_usage) {
                 // round
@@ -65,12 +63,12 @@ static size_t get_post_ops_count(const program_node& node) {
                 }
 
                 // clamp
-                if (q.get_need_clamp()) {
+                if (q_param->has_clamp) {
                     onednn_post_ops_count++;
                 }
             } else {
                 // clamp
-                if (q.get_need_clamp()) {
+                if (q_param->has_clamp) {
                     onednn_post_ops_count += 2;
                 }
                 // round
@@ -200,7 +198,7 @@ bool layout_optimizer::can_fuse_reorder(program_node& prev, program_node& next,
     // Not to fuse reorder if this removal changes input format of its next node which has reuse in fused_op
     if (next.get_preferred_impl_type() == impl_types::onednn) {
         for (auto& fused_op : next.get_fused_primitives()) {
-            if (fused_op.node->is_type<eltwise>()) {
+            if (fused_op.is_type<eltwise>()) {
                 auto out_layout = next.get_output_layout();
                 auto add_type = onednn_add_fusing_helpers::get_add_fusing_type(next, fused_op);
                 if (add_type == add_fusing_type::sum && prev.get_output_layout().format != out_layout.format)
@@ -347,9 +345,10 @@ bool layout_optimizer::can_fuse_reorder(program_node& prev, program_node& next,
             std::set<size_t> dep_idx_set;
             for (auto& p : next.get_fused_primitives()) {
                 // find eltwise sum primitive which has dependency nodes, and gather dependency indices of it.
-                if (p.node->is_type<eltwise>() && p.node->as<eltwise>().get_primitive()->mode == eltwise_mode::sum) {
-                    for (size_t i = p.dep_start_idx; i < p.dep_start_idx + p.total_num_deps; i++)
+                if (p.is_type<eltwise>() && p.typed_desc<eltwise>()->mode == eltwise_mode::sum) {
+                    for (size_t i = p.dep_start_idx; i < p.dep_start_idx + p.total_num_deps; i++) {
                         dep_idx_set.insert(i);
+                    }
                 }
             }
             // The current reorder can be fused if it is a dependency of eltwise sum primitive fused.
@@ -823,7 +822,7 @@ static bool is_node_for_onednn(program_node& node, fully_connected_node const& f
     bool is_suitable_for_onednn = true;
     auto out_layout = node.get_output_layout();
     for (auto& fo : node.get_fused_primitives()) {
-        if (fo.node->is_type<eltwise>()) {
+        if (fo.is_type<eltwise>()) {
             // FC checkings
             auto in_layout = node.get_dependency(fo.dep_start_idx).get_output_layout();
             auto in_dt = in_layout.data_type;
@@ -909,12 +908,11 @@ static bool is_scale_shift(const eltwise_node& node) {
         return false;
 
     auto fused_op0 = node.get_fused_primitives().front();
-    auto fused_op0_node = fused_op0.node;
 
-    if (!fused_op0_node->is_type<eltwise>())
+    if (!fused_op0.is_type<eltwise>())
         return false;
 
-    if (fused_op0_node->as<eltwise>().get_primitive()->mode != eltwise_mode::sum)
+    if (fused_op0.typed_desc<eltwise>()->mode != eltwise_mode::sum)
         return false;
 
     return true;
@@ -1581,9 +1579,9 @@ impl_types layout_optimizer::get_preferred_impl_type(program_node& node, format
         }
 
         for (auto& fo : node.get_fused_primitives()) {
-            if (fo.node->is_type<activation>()) {
+            if (fo.is_type<activation>()) {
                 // Some activations aren't implemented in oneDNN
-                auto activation_prim = fo.node->as<activation>().get_primitive();
+                auto activation_prim = fo.typed_desc<activation>();
                 if (activation_prim->activation_function == activation_func::negative ||
                     activation_prim->activation_function == activation_func::negation ||
                     activation_prim->activation_function == activation_func::sign)
@@ -1628,13 +1626,12 @@ impl_types layout_optimizer::get_preferred_impl_type(program_node& node, format
                 impl_candidate = impl_types::ocl;
         } else {
             for (auto& fo : node.get_fused_primitives()) {
-                if (fo.node->is_type<eltwise>()) {
+                if (fo.is_type<eltwise>()) {
                     // Gemm checkings
                     // TODO: investigate why currently onednn gemm has some "sum" post-op restrictions
                     // which don't correlate with fc checkings in the code above
                     // Temprorary WA: disable onednn gemm with sum post-op inside
-                    auto& e_node = fo.node->as<eltwise>();
-                    if (e_node.get_primitive()->mode == eltwise_mode::sum) {
+                    if (fo.typed_desc<eltwise>()->mode == eltwise_mode::sum) {
                         impl_candidate = impl_types::ocl;
                         break;
                     }
diff --git a/src/plugins/intel_gpu/src/graph/network.cpp b/src/plugins/intel_gpu/src/graph/network.cpp
index 4a2639f43bce9e..9ef406302c7303 100644
--- a/src/plugins/intel_gpu/src/graph/network.cpp
+++ b/src/plugins/intel_gpu/src/graph/network.cpp
@@ -540,7 +540,7 @@ void network::allocate_primitives() {
         if (node->get_preferred_impl_type() == impl_types::onednn) {
             size_t eltw_dep = 0;
             for (auto& fused_op : node->get_fused_primitives()) {
-                if (fused_op.node->is_type<eltwise>() && fused_op.deps.size() == 1) {
+                if (fused_op.is_type<eltwise>() && fused_op.deps.size() == 1) {
                     // If it is first sum, reuse the buffer
                     auto fusing_type = onednn_add_fusing_helpers::get_add_fusing_type(*node, fused_op);
                     if (fusing_type != add_fusing_type::sum || eltw_dep != 0)
diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp
index 0eba6ab10392ad..a3247d65771f2e 100644
--- a/src/plugins/intel_gpu/src/graph/program.cpp
+++ b/src/plugins/intel_gpu/src/graph/program.cpp
@@ -1039,10 +1039,11 @@ void program::fuse_nodes(program_node &fused_node,
                          program_node &peer_node,
                          std::map<primitive_id, std::vector<std::pair<primitive_id, size_t>>>* fusing_history) {
     auto peer_layout = peer_node.get_output_layout();
-    fused_primitive_desc local_desc;
-    local_desc.node = get_node_ptr(peer_node.id());
+    fused_primitive_desc local_desc(peer_node.get_primitive());
+    local_desc.f_param = get_node_ptr(peer_node.id())->get_fuse_params();
     local_desc.dep_start_idx = fused_node.get_dependencies().size();
     local_desc.total_num_deps = peer_node.get_dependencies().size();
+    local_desc.input_layout = peer_node.get_dependency(0).get_output_layout();
     local_desc.output_layout = peer_layout;
     local_desc.activation = activation_func::none;
     if (!peer_node.get_fused_activations_funcs().empty()) {
diff --git a/src/plugins/intel_gpu/src/graph/program_helpers.cpp b/src/plugins/intel_gpu/src/graph/program_helpers.cpp
index 3aae610986bc48..a5598cabe4c97b 100644
--- a/src/plugins/intel_gpu/src/graph/program_helpers.cpp
+++ b/src/plugins/intel_gpu/src/graph/program_helpers.cpp
@@ -203,20 +203,23 @@ bool onednn_add_fusing_helpers::is_full_tensor(const layout& l) {
 
 void onednn_add_fusing_helpers::for_eltwise(
     const program_node& node, eltwise_mode mode,
-    std::function<void(const program_node& p_node, const eltwise_node& e_node,
+    std::function<void(const program_node& p_node,
                     const fused_primitive_desc& desc)> func) {
     for (auto& fo : node.get_fused_primitives()) {
-        if (fo.node->is_type<eltwise>() && fo.node->as<eltwise>().get_primitive()->mode == mode) {
-            func(node, fo.node->as<eltwise>(), fo);
+        if (fo.is_type<eltwise>() && fo.typed_desc<eltwise>()->mode == mode) {
+            func(node, fo);
         }
     }
 }
 
 add_fusing_type onednn_add_fusing_helpers::get_add_fusing_type(
     const program_node& p_node, const fused_primitive_desc& desc) {
-    if (!desc.node->is_type<eltwise>() || desc.node->as<eltwise>().get_primitive()->mode != eltwise_mode::sum) {
+    if (!desc.is_type<eltwise>()) {
         return add_fusing_type::not_supported;
     }
+     if (desc.typed_desc<eltwise>()->mode != eltwise_mode::sum) {
+         return add_fusing_type::not_supported;
+     }
 
     auto& dep_node = p_node.get_dependency(desc.dep_start_idx);
     auto p_layout = p_node.get_output_layout();
diff --git a/src/plugins/intel_gpu/src/graph/program_node.cpp b/src/plugins/intel_gpu/src/graph/program_node.cpp
index 7727f2cd658958..33b67c2290e2ca 100644
--- a/src/plugins/intel_gpu/src/graph/program_node.cpp
+++ b/src/plugins/intel_gpu/src/graph/program_node.cpp
@@ -117,7 +117,7 @@ std::unique_ptr<json_composite> program_node::desc_to_json() const {
     size_t index = 0;
     for (auto& fused_desc : get_fused_primitives()) {
         json_composite fused_node_info;
-        fused_node_info.add("id", fused_desc.node->id());
+        fused_node_info.add("id", fused_desc.desc->id);
         std::vector<primitive_id> dep_ids;
         for (auto dep : fused_desc.deps) {
             dep_ids.push_back(dep.first);
@@ -870,14 +870,13 @@ void program_node::init_onednn_primitive_attributes() {
 
     int32_t num_sum_post_ops = 0;
     for (size_t idx = 0; idx < cldnn_post_ops.size(); idx++) {
-        auto node = cldnn_post_ops[idx].node;
-
-        if (node->is_type<activation>()) {
-            auto fused_desc = node->as<activation>().get_primitive();
+        auto& desc = cldnn_post_ops[idx];
+        if (desc.is_type<activation>()) {
+            auto fused_desc = desc.typed_desc<activation>();;
             if (fused_desc->activation_function == cldnn::activation_func::relu_negative_slope
                 && !fused_desc->additional_params_input.empty()) {
                 auto dep_idx = cldnn_post_ops[idx].dep_start_idx;
-                int oc_dim = node->get_output_layout().feature();
+                int oc_dim = desc.output_layout.get_tensor().feature.size();
                 post_ops.append_prelu(1 << oc_dim);
                 update_onednn_post_op_list(onednn_post_op_type::binary_relu, dep_idx);
             } else if (fused_desc->activation_function == cldnn::activation_func::hard_sigmoid) {
@@ -897,12 +896,11 @@ void program_node::init_onednn_primitive_attributes() {
 
                 update_onednn_post_op_list(onednn_post_op_type::eltwise_act, empty_mem);
             }
-        } else if (node->is_type<eltwise>()) {
-            auto& e_node = node->as<eltwise>();
-            auto dep_idx = cldnn_post_ops[idx].dep_start_idx;
+        } else if (desc.is_type<eltwise>()) {
+            auto dep_idx = desc.dep_start_idx;
             auto in = get_dependency(dep_idx).get_output_layout();
 
-            if (e_node.get_primitive()->mode == eltwise_mode::sum) {
+            if (desc.typed_desc<eltwise>()->mode == eltwise_mode::sum) {
                 auto fusing_type = onednn_add_fusing_helpers::get_add_fusing_type(*this, cldnn_post_ops[idx]);
                 if (fusing_type == add_fusing_type::sum && num_sum_post_ops == 0) {
                     if (is_type<convolution>()) {
@@ -930,20 +928,20 @@ void program_node::init_onednn_primitive_attributes() {
                     update_onednn_post_op_list(onednn_post_op_type::binary_mul, dep_idx);
                 }
             }
-        } else if (node->is_type<quantize>()) {
-            auto& q_node = node->as<quantize>();
-            auto dep_idx = cldnn_post_ops[idx].dep_start_idx;
+        } else if (desc.is_type<quantize>()) {
+            auto dep_idx = desc.dep_start_idx;
 
             // ********************************* Common case with output range usage ********************************* //
-            if (q_node.get_per_tensor_output_range() && q_node.get_output_lo_val() < q_node.get_output_hi_val()) {
+            const auto& q_param = desc.get_typed_fuse_params<kernel_selector::quantize_fuse_params>();
+            if (q_param->per_tensor_output_range && q_param->out_lo < q_param->out_hi) {
                 // 1. pre-scale & pre-shift
                 {
-                    if (q_node.get_per_tensor_input_scale() && q_node.get_per_tensor_input_shift()) {
-                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_input_scale_val(), q_node.get_input_shift_val());
+                    if (q_param->per_tensor_input_scale && q_param->per_tensor_input_shift) {
+                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->in_scale, q_param->in_shift);
                         update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                     } else {
-                        if (q_node.get_per_tensor_input_scale()) {
-                            post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_input_scale_val(), 0.0f);
+                        if (q_param->per_tensor_input_scale) {
+                            post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->in_scale, 0.0f);
                             update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                         } else {
                             auto in_scale = get_dependency(dep_idx++).get_output_layout();
@@ -960,9 +958,9 @@ void program_node::init_onednn_primitive_attributes() {
                             }
                         }
 
-                        if (q_node.get_need_pre_shift()) {
-                            if (q_node.get_per_tensor_input_shift()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_node.get_input_shift_val());
+                        if (q_param->has_pre_shift) {
+                            if (q_param->per_tensor_input_shift) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_param->in_shift);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto in_shift = get_dependency(dep_idx++).get_output_layout();
@@ -975,7 +973,7 @@ void program_node::init_onednn_primitive_attributes() {
                 }
 
                 // 2. round
-                auto out_dt = cldnn_post_ops[idx].output_layout.data_type;
+                auto out_dt = desc.output_layout.data_type;
                 {
                     bool output_type_is_int8 = out_dt == data_types::u8 || out_dt == data_types::i8;
                     if (!output_type_is_int8) {
@@ -986,14 +984,14 @@ void program_node::init_onednn_primitive_attributes() {
 
                 // 3. post-scale & post-shift
                 {
-                    if (q_node.get_need_post_scale() && q_node.get_need_post_shift() &&
-                        q_node.get_per_tensor_output_scale() && q_node.get_per_tensor_output_shift()) {
-                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_output_scale_val(), q_node.get_output_shift_val());
+                    if (q_param->has_post_scale && q_param->has_post_shift &&
+                        q_param->per_tensor_output_scale && q_param->per_tensor_output_shift) {
+                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->out_scale, q_param->out_shift);
                         update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                     } else {
-                        if (q_node.get_need_post_scale()) {
-                            if (q_node.get_per_tensor_output_scale()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_output_scale_val(), 0.0f);
+                        if (q_param->has_post_scale) {
+                            if (q_param->per_tensor_output_scale) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->out_scale, 0.0f);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto out_scale = get_dependency(dep_idx++).get_output_layout();
@@ -1003,9 +1001,9 @@ void program_node::init_onednn_primitive_attributes() {
                             }
                         }
 
-                        if (q_node.get_need_post_shift()) {
-                            if (q_node.get_per_tensor_output_shift()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_node.get_output_shift_val());
+                        if (q_param->has_post_shift) {
+                            if (q_param->per_tensor_output_shift) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_param->out_shift);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto out_shift = get_dependency(dep_idx++).get_output_layout();
@@ -1019,9 +1017,9 @@ void program_node::init_onednn_primitive_attributes() {
 
                 // 4. clamp
                 {
-                    if (q_node.get_need_clamp()) {
-                        float out_lo = q_node.get_need_min_clamp() ? q_node.get_output_lo_val() : data_type_traits::min<float>(out_dt);
-                        float out_hi = q_node.get_need_max_clamp() ? q_node.get_output_hi_val() : data_type_traits::max<float>(out_dt);
+                    if (q_param->has_clamp) {
+                        float out_lo = q_param->has_min_clamp ? q_param->out_lo : data_type_traits::min<float>(out_dt);
+                        float out_hi = q_param->has_max_clamp ? q_param->out_hi : data_type_traits::max<float>(out_dt);
                         post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_clip, out_lo, out_hi);
                         update_onednn_post_op_list(onednn_post_op_type::eltwise_clip, empty_mem);
                     }
@@ -1030,7 +1028,7 @@ void program_node::init_onednn_primitive_attributes() {
             } else {
                 // 1. clamp
                 {
-                    if (q_node.get_need_clamp()) {
+                    if (q_param->has_clamp) {
                         auto in_lo = get_dependency(dep_idx++).get_output_layout();
                         auto in_hi = get_dependency(dep_idx++).get_output_layout();
                         dnnl::algorithm clamp_max = dnnl::algorithm::binary_max;
@@ -1047,16 +1045,16 @@ void program_node::init_onednn_primitive_attributes() {
 
                 // 2. pre-scale & pre-shift
                 {
-                    if (q_node.get_per_tensor_input_scale() && q_node.get_per_tensor_input_shift()) {
-                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_input_scale_val(), q_node.get_input_shift_val());
+                    if (q_param->per_tensor_input_scale && q_param->per_tensor_input_shift) {
+                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->in_scale, q_param->in_shift);
                         update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                     } else {
-                        if (q_node.get_per_tensor_input_scale()) {
-                            post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_input_scale_val(), 0.0f);
+                        if (q_param->per_tensor_input_scale) {
+                            post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->in_scale, 0.0f);
                             update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                         } else {
                             auto in_scale = get_dependency(dep_idx++).get_output_layout();
-                            if (idx == 0 && !q_node.get_need_clamp() && !has_out_scales(attrs) && in_scale.data_type == data_types::f32 &&
+                            if (idx == 0 && !q_param->has_clamp && !has_out_scales(attrs) && in_scale.data_type == data_types::f32 &&
                                 is_type<convolution>() &&
                                 !data_type_traits::is_floating_point(get_dependency(0).get_output_layout().data_type)) {
                                 int mask = in_scale.count() > 1 ? 2 : 0;
@@ -1069,9 +1067,9 @@ void program_node::init_onednn_primitive_attributes() {
                             }
                         }
 
-                        if (q_node.get_need_pre_shift()) {
-                            if (q_node.get_per_tensor_input_shift()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_node.get_input_shift_val());
+                        if (q_param->has_pre_shift) {
+                            if (q_param->per_tensor_input_shift) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_param->in_shift);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto in_shift = get_dependency(dep_idx++).get_output_layout();
@@ -1091,14 +1089,14 @@ void program_node::init_onednn_primitive_attributes() {
 
                 // 4. post-scale & post-shift
                 {
-                    if (q_node.get_need_post_scale() && q_node.get_need_post_shift() &&
-                        q_node.get_per_tensor_output_scale() && q_node.get_per_tensor_output_shift()) {
-                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_output_scale_val(), q_node.get_output_shift_val());
+                    if (q_param->has_post_scale && q_param->has_post_shift &&
+                        q_param->per_tensor_output_scale && q_param->per_tensor_output_shift) {
+                        post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->out_scale, q_param->out_shift);
                         update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                     } else {
-                        if (q_node.get_need_post_scale()) {
-                            if (q_node.get_per_tensor_output_scale()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_node.get_output_scale_val(), 0.0f);
+                        if (q_param->has_post_scale) {
+                            if (q_param->per_tensor_output_scale) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, q_param->out_scale, 0.0f);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto out_scale = get_dependency(dep_idx++).get_output_layout();
@@ -1108,9 +1106,9 @@ void program_node::init_onednn_primitive_attributes() {
                             }
                         }
 
-                        if (q_node.get_need_post_shift()) {
-                            if (q_node.get_per_tensor_output_shift()) {
-                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_node.get_output_shift_val());
+                        if (q_param->has_post_shift) {
+                            if (q_param->per_tensor_output_shift) {
+                                post_ops.append_eltwise(1.0f, dnnl::algorithm::eltwise_linear, 1.0f, q_param->out_shift);
                                 update_onednn_post_op_list(onednn_post_op_type::eltwise_linear, empty_mem);
                             } else {
                                 auto out_shift = get_dependency(dep_idx++).get_output_layout();
@@ -1122,10 +1120,10 @@ void program_node::init_onednn_primitive_attributes() {
                     }
                 }
             }
-        } else if (node->is_type<reorder>()) {
+        } else if (desc.is_type<reorder>()) {
             continue;
         } else {
-            throw std::runtime_error("Unsupported fused op of " + node->get_primitive()->type_string() + " type for oneDNN primitive");
+            throw std::runtime_error("Unsupported fused op of " + desc.desc->type_string() + " type for oneDNN primitive");
         }
     }