diff --git a/samples/cpp/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.cpp b/samples/cpp/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.cpp
index e692110027..8b48dbade0 100644
--- a/samples/cpp/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.cpp
+++ b/samples/cpp/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.cpp
@@ -22,14 +22,10 @@ int main(int argc, char* argv[]) try {
     
     std::string device = "CPU";
 
-    ov::genai::SchedulerConfig scheduler_config;
-    scheduler_config.cache_size = 5;
-
     ov::genai::LLMPipeline pipe(
         model_path,
         device,
-        ov::genai::prompt_lookup(true),
-        ov::genai::scheduler_config(scheduler_config));
+        ov::genai::prompt_lookup(true));
 
     auto streamer = [](std::string subword) {
         std::cout << subword << std::flush;
diff --git a/samples/cpp/speculative_decoding_lm/speculative_decoding_lm.cpp b/samples/cpp/speculative_decoding_lm/speculative_decoding_lm.cpp
index 487296566b..e10228863f 100644
--- a/samples/cpp/speculative_decoding_lm/speculative_decoding_lm.cpp
+++ b/samples/cpp/speculative_decoding_lm/speculative_decoding_lm.cpp
@@ -26,14 +26,10 @@ int main(int argc, char* argv[]) try {
     // Please, set device for main model in `LLMPipeline` constructor and in in `ov::genai::draft_model` for draft.
     std::string main_device = "CPU", draft_device = "CPU";
 
-    ov::genai::SchedulerConfig scheduler_config;
-    scheduler_config.cache_size = 5;
-
     ov::genai::LLMPipeline pipe(
         main_model_path,
         main_device,
-        ov::genai::draft_model(draft_model_path, draft_device),
-        ov::genai::scheduler_config(scheduler_config));
+        ov::genai::draft_model(draft_model_path, draft_device));
 
     auto streamer = [](std::string subword) {
         std::cout << subword << std::flush;
diff --git a/samples/python/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.py b/samples/python/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.py
index 557897b6b1..726391ba9b 100755
--- a/samples/python/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.py
+++ b/samples/python/prompt_lookup_decoding_lm/prompt_lookup_decoding_lm.py
@@ -18,11 +18,8 @@ def main():
     args = parser.parse_args()
 
     device = 'CPU'
-    scheduler_config = openvino_genai.SchedulerConfig()
-    # cache params
-    scheduler_config.cache_size = 2
 
-    pipe = openvino_genai.LLMPipeline(args.model_dir, device, scheduler_config=scheduler_config, prompt_lookup=True)
+    pipe = openvino_genai.LLMPipeline(args.model_dir, device, prompt_lookup=True)
     
     config = openvino_genai.GenerationConfig()
     config.max_new_tokens = 100
diff --git a/samples/python/speculative_decoding_lm/speculative_decoding_lm.py b/samples/python/speculative_decoding_lm/speculative_decoding_lm.py
index 612e59474e..217b8a2730 100755
--- a/samples/python/speculative_decoding_lm/speculative_decoding_lm.py
+++ b/samples/python/speculative_decoding_lm/speculative_decoding_lm.py
@@ -25,13 +25,9 @@ def main():
     main_device = 'CPU'  # GPU can be used as well
     draft_device = 'CPU'
 
-    scheduler_config = openvino_genai.SchedulerConfig()
-    # cache params
-    scheduler_config.cache_size = 2
-
     draft_model = openvino_genai.draft_model(args.draft_model_dir, draft_device)
 
-    pipe = openvino_genai.LLMPipeline(args.model_dir, main_device, scheduler_config=scheduler_config, draft_model=draft_model)
+    pipe = openvino_genai.LLMPipeline(args.model_dir, main_device, draft_model=draft_model)
     
     config = openvino_genai.GenerationConfig()
     config.max_new_tokens = 100
diff --git a/src/cpp/src/block_manager.hpp b/src/cpp/src/block_manager.hpp
index dc82897dc8..4ca263777b 100644
--- a/src/cpp/src/block_manager.hpp
+++ b/src/cpp/src/block_manager.hpp
@@ -205,14 +205,20 @@ class BlockAllocator {
      * Blocks returned will be vectors with this size, each vector entry to be associated with a separate layer's KV cache.
      */
     BlockAllocator(size_t num_blocks, bool enable_prefix_caching, size_t num_layers = 1) :
-            m_free_blocks_num(num_layers, num_blocks), m_total_num_blocks(num_blocks), m_num_layers(num_layers), m_enable_prefix_caching(enable_prefix_caching), m_overwriteable_blocks(num_layers) {
+            m_total_num_blocks(num_blocks), m_num_layers(num_layers), m_enable_prefix_caching(enable_prefix_caching), m_overwriteable_blocks(num_layers) {
         OPENVINO_ASSERT(num_layers != 0, "num_layers must be non-zero");
         m_free_blocks.resize(m_num_layers);
-        for (auto& per_layer_block_list : m_free_blocks) {
-            for (int block_id = 0; block_id < m_total_num_blocks; ++block_id) {
-                per_layer_block_list.push_back(std::make_shared<KVCacheBlock>(block_id));
+        if (num_blocks > 0) {
+            m_free_blocks_num = std::vector<size_t>(num_layers, num_blocks);
+            for (auto& per_layer_block_list : m_free_blocks) {
+                for (int block_id = 0; block_id < m_total_num_blocks; ++block_id) {
+                    per_layer_block_list.push_back(std::make_shared<KVCacheBlock>(block_id));
+                }
             }
         }
+        else {
+            m_free_blocks_num = std::vector<size_t>(m_num_layers, 0);
+        }
     }
 
     ~BlockAllocator() {
@@ -220,6 +226,21 @@ class BlockAllocator {
         // OPENVINO_ASSERT(m_total_num_blocks == m_free_blocks.size());
     }
 
+    void increase_kv_blocks_number(size_t new_kv_blocks_count) {
+        OPENVINO_ASSERT(new_kv_blocks_count > m_total_num_blocks, "New blocks number should be more than previous blocks number.");
+        size_t added_blocks = new_kv_blocks_count - m_total_num_blocks;
+        for (auto idx = 0; idx < m_free_blocks_num.size(); idx++) {
+            m_free_blocks_num[idx] += added_blocks;
+        }
+        for (auto& per_layer_block_list : m_free_blocks) {
+            for (int block_id = m_total_num_blocks; block_id < new_kv_blocks_count; ++block_id) {
+                per_layer_block_list.push_back(std::make_shared<KVCacheBlock>(block_id));
+            }
+        }
+        m_total_num_blocks = new_kv_blocks_count;
+    }
+
+
     /**
      * Returns the number of free blocks for a given layer.
      * @param layer_idx Index of the layer.
@@ -459,6 +480,13 @@ class BlockAllocator {
         for (size_t layer_idx = 0; layer_idx < m_num_layers; layer_idx++) sum += num_free_blocks(layer_idx);
         return static_cast<float>(m_num_layers * m_total_num_blocks - sum) / (m_num_layers * m_total_num_blocks) * 100;
     }
+
+    /**
+     * @return The total number of KV blocks .
+     */
+    size_t get_total_number_of_kv_blocks() const {
+        return m_total_num_blocks;
+    }
 };
 
 /**
@@ -713,6 +741,21 @@ class BlockManager {
         return m_allocator.get_used_percentage();
     }
 
+    /**
+     * Increases the number of KV blocks.
+     * @param num_blocks The new number of KV-blocks.
+     */
+    void increase_kv_blocks_number(size_t num_blocks) {
+        m_allocator.increase_kv_blocks_number(num_blocks);
+    }
+
+    /**
+     * @return The total number of KV blocks .
+     */
+    size_t get_total_number_of_kv_blocks() const {
+        return m_allocator.get_total_number_of_kv_blocks();
+    }
+
     /**
      * @brief Forks a sequence, establishing a new sequence from an existing one, reusing
      * currently allocated blocks of the existing sequence.
diff --git a/src/cpp/src/cache_manager.hpp b/src/cpp/src/cache_manager.hpp
index a7444555ab..0c04823f4f 100644
--- a/src/cpp/src/cache_manager.hpp
+++ b/src/cpp/src/cache_manager.hpp
@@ -15,38 +15,118 @@ class CacheManager {
     DeviceConfig m_device_config;
     std::vector<ov::Tensor> m_key_cache;
     std::vector<ov::Tensor> m_value_cache;
+    size_t m_num_allocated_kv_blocks = 0;
     ov::Core m_core;
+    ov::InferRequest m_request;
+
+    ov::Shape set_first_dim_and_make_static(const ov::PartialShape& shape, size_t dim) {
+        ov::PartialShape res_shape = shape;
+        res_shape[0] = dim;
+        OPENVINO_ASSERT(res_shape.is_static());
+        return res_shape.to_shape();
+    }
+
+    void update_request_tensor(size_t decoder_layer_id) {
+        m_request.set_tensor(std::string("key_cache.") + std::to_string(decoder_layer_id), m_key_cache[decoder_layer_id]);
+        m_request.set_tensor(std::string("value_cache.") + std::to_string(decoder_layer_id), m_value_cache[decoder_layer_id]);
+    }
 
 public:
-    explicit CacheManager(const DeviceConfig &device_config, ov::Core core) :
+    explicit CacheManager(const DeviceConfig &device_config, ov::InferRequest request, ov::Core core) :
             m_device_config(device_config),
+            m_request(request),
             m_core(core) {
         m_key_cache.reserve(m_device_config.get_num_layers());
         m_value_cache.reserve(m_device_config.get_num_layers());
+    }
+
+    void allocate_cache_if_needed(size_t num_kv_blocks) {
+        if (m_num_allocated_kv_blocks >= num_kv_blocks) {
+            return;
+        }
+        OPENVINO_ASSERT(m_key_cache.size() == m_value_cache.size());
+        m_num_allocated_kv_blocks = num_kv_blocks;
+        ov::Shape value_cache_shape = set_first_dim_and_make_static(m_device_config.get_value_cache_shape(), num_kv_blocks);
+        ov::Shape key_cache_shape = set_first_dim_and_make_static(m_device_config.get_key_cache_shape(), num_kv_blocks);
+
+        const std::string device_name = m_device_config.get_device();
+
+        ov::Coordinate start_key{0,0,0,0};
+        ov::Coordinate start_value{0,0,0,0};
 
-        const std::string device_name = device_config.get_device();
         if (device_name.find("GPU") == std::string::npos) {// Allocate KV caches
             for (size_t decoder_layer_id = 0; decoder_layer_id < m_device_config.get_num_layers(); ++decoder_layer_id) {
-                ov::Tensor key_cache(device_config.get_cache_precision(), device_config.get_key_cache_shape());
-                ov::Tensor value_cache(device_config.get_cache_precision(), device_config.get_value_cache_shape());
+                ov::Tensor key_cache(m_device_config.get_cache_precision(), key_cache_shape);
+                ov::Tensor value_cache(m_device_config.get_cache_precision(), value_cache_shape);
+
+                auto key_cache_roi_end = static_cast<unsigned char*>(key_cache.data());
+                auto value_cache_roi_end = static_cast<unsigned char*>(value_cache.data());
+                size_t key_roi_size_byte = 0;
+                size_t value_roi_size_byte = 0;
+
+                if (m_key_cache.size() > decoder_layer_id) {
+                    ov::Coordinate end_key = m_key_cache[decoder_layer_id].get_shape();
+                    ov::Coordinate end_value = m_value_cache[decoder_layer_id].get_shape();
+
+                    key_roi_size_byte = m_key_cache[decoder_layer_id].get_byte_size();
+                    value_roi_size_byte = m_value_cache[decoder_layer_id].get_byte_size();
+                    key_cache_roi_end = static_cast<unsigned char*>(key_cache.data()) + key_roi_size_byte;
+                    value_cache_roi_end = static_cast<unsigned char*>(value_cache.data()) + value_roi_size_byte;
+                    
+                    // copy current cache data
+                    ov::Tensor dst_key_roi(key_cache, start_key, end_key);
+                    ov::Tensor dst_value_roi(value_cache, start_value, end_value);
+
+                    m_key_cache[decoder_layer_id].copy_to(dst_key_roi);
+                    m_value_cache[decoder_layer_id].copy_to(dst_value_roi);
+
+                }
 
-                // force allocation
-                std::memset(key_cache.data(), 0, key_cache.get_byte_size());
-                std::memset(value_cache.data(), 0, value_cache.get_byte_size());
+                // Some optimizations like AVX2, AVX512, AMX require a minimal shape and 
+                // perform multiplying by zero on the excess data. Uninitialized tensor data contain NAN's, 
+                // so NAN * 0 returns non-zero invalid data.
+                // So we need to set zeros to all newly allocated tensors data.
+                std::memset(key_cache_roi_end, 0, key_cache.get_byte_size() - key_roi_size_byte);
+                std::memset(value_cache_roi_end, 0, value_cache.get_byte_size() - value_roi_size_byte);
+                
+                // set new cache tensors
+                if (m_key_cache.size() > decoder_layer_id) {
+                    m_key_cache[decoder_layer_id] = key_cache;
+                    m_value_cache[decoder_layer_id] = value_cache;
+                }
+                else {
+                    m_key_cache.emplace_back(key_cache);
+                    m_value_cache.emplace_back(value_cache);
+                }
 
-                m_key_cache.emplace_back(key_cache);
-                m_value_cache.emplace_back(value_cache);
+                update_request_tensor(decoder_layer_id);
             }
         } else {
             auto remote_context = m_core.get_default_context(device_name);
             for (size_t decoder_layer_id = 0; decoder_layer_id < m_device_config.get_num_layers(); ++decoder_layer_id) {
-                ov::Tensor key_cache = remote_context.create_tensor(device_config.get_cache_precision(),
-                                                                    device_config.get_key_cache_shape());
-                ov::Tensor value_cache = remote_context.create_tensor(device_config.get_cache_precision(),
-                                                                      device_config.get_value_cache_shape());
-
-                m_key_cache.emplace_back(key_cache);
-                m_value_cache.emplace_back(value_cache);
+                ov::Tensor key_cache = remote_context.create_tensor(m_device_config.get_cache_precision(),
+                                                                    key_cache_shape);
+                ov::Tensor value_cache = remote_context.create_tensor(m_device_config.get_cache_precision(),
+                                                                      value_cache_shape);
+                
+                if (m_key_cache.size() > decoder_layer_id) {
+                    ov::Coordinate end_key = m_key_cache[decoder_layer_id].get_shape();
+                    ov::Coordinate end_value = m_value_cache[decoder_layer_id].get_shape();
+
+                    // copy current cache data
+                    ov::RemoteTensor dst_key_roi(key_cache, start_key, end_key);
+                    ov::RemoteTensor dst_value_roi(value_cache, start_value, end_value);
+                    dst_key_roi.copy_from(m_key_cache[decoder_layer_id]);
+                    dst_value_roi.copy_from(m_value_cache[decoder_layer_id]);
+
+                    m_key_cache[decoder_layer_id] = key_cache;
+                    m_value_cache[decoder_layer_id] = value_cache;
+                }
+                else {
+                    m_key_cache.emplace_back(key_cache);
+                    m_value_cache.emplace_back(value_cache);
+                }
+                update_request_tensor(decoder_layer_id);
             }
         }
     }
@@ -62,8 +142,8 @@ class CacheManager {
     }
 
     void copy_blocks(const std::map<size_t, std::list<size_t>>& block_copy_map) {
-        ov::Shape key_shape = m_device_config.get_key_cache_shape();
-        ov::Shape value_shape = m_device_config.get_value_cache_shape();
+        ov::Shape key_shape = set_first_dim_and_make_static(m_device_config.get_key_cache_shape(), m_num_allocated_kv_blocks);
+        ov::Shape value_shape = set_first_dim_and_make_static(m_device_config.get_value_cache_shape(), m_num_allocated_kv_blocks);
 
         ov::Coordinate key_src_start_roi(key_shape.size(), 0);
         ov::Coordinate key_src_end_roi = key_shape;
@@ -98,5 +178,13 @@ class CacheManager {
             }
         }
     }
+
+    std::shared_ptr<Core> get_core() {
+        return std::make_shared<Core>(m_core);
+    }
+
+    std::shared_ptr<DeviceConfig> get_device_config() {
+        return std::make_shared<DeviceConfig>(m_device_config);
+    }
 };
 }
diff --git a/src/cpp/src/continuous_batching_impl.cpp b/src/cpp/src/continuous_batching_impl.cpp
index e1ffd062de..52ec6a8302 100644
--- a/src/cpp/src/continuous_batching_impl.cpp
+++ b/src/cpp/src/continuous_batching_impl.cpp
@@ -53,11 +53,7 @@ void ContinuousBatchingPipeline::ContinuousBatchingImpl::init(
     ov::InferRequest infer_request = compiled_model.create_infer_request();
 
     // setup KV caches
-    m_cache_manager = std::make_shared<CacheManager>(device_config, core);
-    for (size_t decoder_layer_id = 0; decoder_layer_id < device_config.get_num_layers(); ++decoder_layer_id) {
-        infer_request.set_tensor(std::string("key_cache.") + std::to_string(decoder_layer_id), m_cache_manager->get_key_cache(decoder_layer_id));
-        infer_request.set_tensor(std::string("value_cache.") + std::to_string(decoder_layer_id), m_cache_manager->get_value_cache(decoder_layer_id));
-    }
+    m_cache_manager = std::make_shared<CacheManager>(device_config, infer_request, core);
 
     SchedulerConfig updated_config = scheduler_config;
     // update KV blocks number in scheduler config
@@ -71,8 +67,7 @@ void ContinuousBatchingPipeline::ContinuousBatchingImpl::init(
         // as it may lead to performance slowdown
         can_use_partial_preemption = false;
     }
-
-    m_scheduler = std::make_shared<Scheduler>(device_config.get_block_size(), updated_config, device_config.get_num_layers(), can_use_partial_preemption);
+    m_scheduler = std::make_shared<Scheduler>(device_config.get_block_size(), m_cache_manager, updated_config, device_config.get_num_layers(), can_use_partial_preemption);
     // and finally create model runner
     bool is_use_cache_eviction = m_scheduler->get_config().use_cache_eviction;
     m_model_runner = std::make_shared<ModelRunner>(infer_request, m_scheduler->get_block_size(), device_config.get_num_layers(), is_use_cache_eviction);
@@ -133,7 +128,6 @@ void ContinuousBatchingPipeline::ContinuousBatchingImpl::step() {
     _pull_awaiting_requests();
 
     m_pipeline_metrics.requests = m_requests.size();
-
     Scheduler::Output scheduler_output;
     {
         static ManualTimer timer("scheduling");
diff --git a/src/cpp/src/device_config.hpp b/src/cpp/src/device_config.hpp
index 2af4559ef1..371142701c 100644
--- a/src/cpp/src/device_config.hpp
+++ b/src/cpp/src/device_config.hpp
@@ -12,7 +12,7 @@
 namespace ov::genai {
 class DeviceConfig {
     ov::element::Type m_kv_cache_type;
-    ov::Shape m_key_cache_shape, m_value_cache_shape;
+    ov::PartialShape m_key_cache_shape, m_value_cache_shape;
     ov::Shape::value_type m_num_kv_heads, m_head_size, m_num_decoder_layers;
     size_t m_num_kv_blocks = 0;
     size_t m_block_size = 0;
@@ -80,11 +80,10 @@ class DeviceConfig {
             OPENVINO_THROW(m_device, " is not supported by OpenVINO Continuous Batching");
         }
 
-        OPENVINO_ASSERT(scheduling_config.num_kv_blocks > 0 || scheduling_config.cache_size > 0, "num_kv_blocks or cache_size should be more than zero.");
         if (scheduling_config.num_kv_blocks > 0) {
             m_num_kv_blocks = scheduling_config.num_kv_blocks;
         }
-        else {
+        else if (scheduling_config.cache_size > 0) {
             m_cache_size = scheduling_config.cache_size;
         }
     }
@@ -104,23 +103,22 @@ class DeviceConfig {
                 m_head_size += 8;
         }
 
-        if (m_num_kv_blocks == 0) {
-            OPENVINO_ASSERT(m_cache_size > 0, "num_kv_blocks or cache_size should be more than zero.");
+        if (m_num_kv_blocks == 0 && m_cache_size > 0) {
             size_t size_in_bytes = m_cache_size * 1024 * 1024 * 1024;
             m_num_kv_blocks = size_in_bytes / (m_num_decoder_layers * 2 * m_num_kv_heads * m_block_size * m_head_size * m_kv_cache_type.size());
         }
 
-        m_key_cache_shape = m_value_cache_shape = ov::Shape{m_num_kv_blocks,
-                                                            m_num_kv_heads,
-                                                            m_block_size,
-                                                            m_head_size};
+        m_key_cache_shape = m_value_cache_shape = ov::PartialShape{ov::Dimension::dynamic(),
+                                                                   ov::Dimension(m_num_kv_heads),
+                                                                   ov::Dimension(m_block_size),
+                                                                   ov::Dimension(m_head_size)};
 
         if (m_device.find("GPU") != std::string::npos) {
             // Update key shape, as the key's shape is different from the value's shape
-            m_key_cache_shape = ov::Shape{m_num_kv_blocks,
-                                          m_num_kv_heads,
-                                          m_head_size,
-                                          m_block_size};
+            m_key_cache_shape = ov::PartialShape{ov::Dimension::dynamic(),
+                                                 ov::Dimension(m_num_kv_heads),
+                                                 ov::Dimension(m_head_size),
+                                                 ov::Dimension(m_block_size)};
         }
     }
 
@@ -136,13 +134,13 @@ class DeviceConfig {
         return m_num_decoder_layers;
     }
 
-    ov::Shape get_key_cache_shape() const {
-        OPENVINO_ASSERT(!m_key_cache_shape.empty());
+    ov::PartialShape get_key_cache_shape() const {
+        OPENVINO_ASSERT(m_key_cache_shape.size());
         return m_key_cache_shape;
     }
 
-    ov::Shape get_value_cache_shape() const {
-        OPENVINO_ASSERT(!m_value_cache_shape.empty());
+    ov::PartialShape get_value_cache_shape() const {
+        OPENVINO_ASSERT(m_value_cache_shape.size());
         return m_value_cache_shape;
     }
 
@@ -153,5 +151,9 @@ class DeviceConfig {
     size_t get_block_size() const {
         return m_block_size;
     }
+
+    size_t get_block_size_in_bytes() const {
+        return m_num_decoder_layers * 2 * m_num_kv_heads * m_block_size * m_head_size * get_cache_precision().size();
+    }
 };
 }
diff --git a/src/cpp/src/llm_pipeline.cpp b/src/cpp/src/llm_pipeline.cpp
index 33180a9199..be5ecf17fa 100644
--- a/src/cpp/src/llm_pipeline.cpp
+++ b/src/cpp/src/llm_pipeline.cpp
@@ -718,7 +718,9 @@ ov::genai::LLMPipeline::LLMPipeline(
     const ov::AnyMap& properties
 ){
     auto start_time = std::chrono::steady_clock::now();
-    if (properties.find(ov::genai::scheduler_config.name()) != properties.end()) {
+    if (properties.find(ov::genai::scheduler_config.name()) != properties.end() || 
+        properties.find(utils::DRAFT_MODEL_ARG_NAME) != properties.end() || 
+        properties.find(ov::genai::prompt_lookup.name()) != properties.end()) {
         auto [plugin_config, scheduler_config] = utils::split_scheduler_config(properties);
         m_pimpl = std::make_unique<ContinuousBatchingAdapter>(models_path, tokenizer, scheduler_config, device, plugin_config);
     } else if (device == "NPU") {
@@ -737,7 +739,9 @@ ov::genai::LLMPipeline::LLMPipeline(
 ){
     auto start_time = std::chrono::steady_clock::now();
 
-    if (config.find(ov::genai::scheduler_config.name()) != config.end()) {
+    if (config.find(ov::genai::scheduler_config.name()) != config.end() || 
+        config.find(utils::DRAFT_MODEL_ARG_NAME) != config.end() || 
+        config.find(ov::genai::prompt_lookup.name()) != config.end()) {
         auto [plugin_config, scheduler_config] = utils::split_scheduler_config(config);
         m_pimpl = std::make_unique<ContinuousBatchingAdapter>(models_path, scheduler_config, device, plugin_config);
     } else if (device == "NPU") {
@@ -760,7 +764,10 @@ ov::genai::LLMPipeline::LLMPipeline(
     auto [core_properties, plugin_config] = ov::genai::utils::split_core_compile_config(config);
 
     auto start_time = std::chrono::steady_clock::now();
-    if (plugin_config.find(ov::genai::scheduler_config.name()) != plugin_config.end()) {
+    if (plugin_config.find(ov::genai::scheduler_config.name()) != plugin_config.end() || 
+        plugin_config.find(utils::DRAFT_MODEL_ARG_NAME) != plugin_config.end() || 
+        plugin_config.find(ov::genai::prompt_lookup.name()) != plugin_config.end()){
+
         auto [plugin_config_, scheduler_config] = utils::split_scheduler_config(plugin_config);
         m_pimpl = std::make_unique<ContinuousBatchingAdapter>(model_str, weights_tensor,
                                                               tokenizer, scheduler_config, device, plugin_config_, generation_config);
diff --git a/src/cpp/src/scheduler.hpp b/src/cpp/src/scheduler.hpp
index 6de4adaa47..da65c68bec 100644
--- a/src/cpp/src/scheduler.hpp
+++ b/src/cpp/src/scheduler.hpp
@@ -7,10 +7,12 @@
 #include <cstdlib>
 #include <vector>
 
+#include "openvino/runtime/intel_gpu/properties.hpp"
 #include "openvino/genai/scheduler_config.hpp"
 #include "device_config.hpp"
 #include "block_manager.hpp"
 #include "sequence_group.hpp"
+#include "cache_manager.hpp"
 
 namespace ov::genai {
 class Scheduler {
@@ -20,6 +22,13 @@ class Scheduler {
     BlockManager m_block_manager;
     friend class CacheStateDumper;
 
+    bool m_dynamic_memory_allocation = false;
+
+    // Dynamic KV-cache allocation params
+    size_t m_kv_blocks_initial_multiplier = 2;
+    const float m_cache_growth_factor = 2; // commmon values 1.5 or 2
+
+    std::shared_ptr<CacheManager> m_cache_manager;
 public:
     struct Output {
         // IDs of scheduled groups
@@ -36,15 +45,20 @@ class Scheduler {
         float m_cache_usage = 0.0;
     };
 
-    explicit Scheduler(size_t block_size, const SchedulerConfig & config = {}, size_t num_layers = 1, bool can_use_partial_preemption = true) :
+    explicit Scheduler(size_t block_size, std::shared_ptr<CacheManager> cache_manager, const SchedulerConfig & config = {}, size_t num_layers = 1, bool can_use_partial_preemption = true) :
+            m_cache_manager(cache_manager),
             m_can_use_partial_preemption(can_use_partial_preemption),
             m_config(config),
             m_block_manager(m_config.num_kv_blocks, m_config.enable_prefix_caching, block_size, num_layers) {
+        
         OPENVINO_ASSERT(num_layers != 0, "num_layers must be non-zero");
     }
 
     Output schedule(std::vector<SequenceGroup::Ptr>& sequence_groups) {
         Output scheduler_output;
+        if (m_block_manager.get_total_number_of_kv_blocks() == 0) {
+            _initialize_cache(sequence_groups);
+        }
 
         if (m_config.dynamic_split_fuse) {
             // deepspeed-mii case
@@ -64,9 +78,9 @@ class Scheduler {
             }
         }
 
+        m_cache_manager->allocate_cache_if_needed(m_block_manager.get_total_number_of_kv_blocks());
         _clear_waiting_sequences(sequence_groups);
         scheduler_output.m_cache_usage = m_block_manager.get_used_percentage();
-
         return scheduler_output;
     }
 
@@ -236,8 +250,13 @@ class Scheduler {
                 OPENVINO_ASSERT(currently_allocated_token_slots >= occupied_token_slots, "internal error");
                 size_t available_slots = currently_allocated_token_slots - occupied_token_slots,
                        required_slots = num_scheduled_tokens > available_slots ? num_scheduled_tokens - available_slots : 0;
-                size_t num_required_blocks = (required_slots + block_size - 1) / block_size, num_free_blocks = m_block_manager.num_free_blocks();
-                size_t num_scheduled_blocks = std::min(num_required_blocks, num_free_blocks);
+                size_t num_required_blocks = (required_slots + block_size - 1) / block_size;
+                while (num_required_blocks > m_block_manager.num_free_blocks()) {
+                    if (!_try_increase_cache()) {
+                        break;
+                    }
+                }
+                size_t num_scheduled_blocks = std::min(num_required_blocks, m_block_manager.num_free_blocks());
                 // some scheduled blocks can be no fully occupied, so we need to take min between num_scheduled_blocks
                 // and total "scheduled capacity"
                 num_scheduled_tokens = std::min(num_scheduled_tokens, available_slots + num_scheduled_blocks * block_size);
@@ -289,10 +308,16 @@ class Scheduler {
                 size_t num_scheduled_tokens_per_seq = std::min(available_tokens_per_seq_in_megabatch, num_available_tokens_per_seq);
                 sequence_group->schedule_tokens(num_scheduled_tokens_per_seq);
 
+                while (!m_block_manager.can_append_slots(sequence_group)){
+                    if (!_try_increase_cache()) {
+                        break;
+                    }
+                }
+
                 _apply_preemption(sequence_group_id, sequence_groups);
 
                 // if we can't preemt any more sequences, clear scheduled tokens and move to next sequence
-                if (!m_block_manager.can_append_slots(sequence_group)){
+                if (!m_block_manager.can_append_slots(sequence_group)) {
                     sequence_group->clear_scheduled_tokens();
                     continue;
                 }
@@ -370,6 +395,11 @@ class Scheduler {
                 // apply KV cache limitations
                 size_t block_size = get_block_size();
                 const size_t num_required_blocks = (sequence_len + block_size - 1) / block_size;
+                while (!m_block_manager.can_allocate_blocks(num_required_blocks)){
+                    if (!_try_increase_cache()) {
+                        break;
+                    }
+                }
                 if (!m_block_manager.can_allocate_blocks(num_required_blocks))
                     break;
 
@@ -405,6 +435,86 @@ class Scheduler {
             sequence_groups[sequence_group_id]->clear_waiting_sequences();
         }
     }
+
+    size_t _get_available_gpu_memory() {
+        auto device_config = m_cache_manager->get_device_config();
+        auto core = m_cache_manager->get_core();
+        auto device = device_config->get_device();
+        OPENVINO_ASSERT(device.find("GPU") != std::string::npos, "_get_available_gpu_memory() is applicable for GPU only.");
+        auto memory_statistics = core->get_property(device, ov::intel_gpu::memory_statistics);
+        auto device_type = core->get_property(device, ov::device::type);
+
+        // sum up all used device memory
+        std::vector<std::string> device_memory_types = {"cl_mem", "usm_device"};
+        size_t used_device_mem = 0;
+        for (auto mem_type: device_memory_types) {
+            used_device_mem += memory_statistics[mem_type];
+        }
+
+        if (device_type == ov::device::Type::INTEGRATED) {
+            used_device_mem += memory_statistics["usm_host"];
+        }
+
+        // there could be unaccounted extra memory reserved by kernels, kept
+        // in memory pools, etc
+        // therefore, add a threshold to account for this
+        float used_memory_threshold = 1.1;
+        used_device_mem *= used_memory_threshold;
+
+        // total device memory in bytes
+        auto total_device_memory = core->get_property(device, ov::intel_gpu::device_total_mem_size);
+
+        return total_device_memory - used_device_mem;
+    }
+
+    void _initialize_cache(const std::vector<SequenceGroup::Ptr>& sequence_groups) {
+        size_t blocks_sum = 0;
+        for (auto idx = 0; idx < sequence_groups.size(); idx++) {
+            auto seq_length = sequence_groups[idx]->get_prompt_len() * m_kv_blocks_initial_multiplier;
+            auto gen_config = sequence_groups[idx]->get_sampling_parameters();
+            seq_length = std::min(seq_length, sequence_groups[idx]->get_prompt_len() + gen_config.get_max_new_tokens(sequence_groups[idx]->get_prompt_len()));
+            size_t blocks_num = std::ceil((float)seq_length / m_block_manager.get_block_size());
+            if (gen_config.is_beam_search()) {
+                blocks_num *= gen_config.num_beams;
+            } else if (gen_config.is_multinomial()) {
+                blocks_num *= gen_config.num_return_sequences;
+            }
+            blocks_sum  += blocks_num;
+        }
+        m_block_manager.increase_kv_blocks_number(blocks_sum);
+        m_dynamic_memory_allocation = true;
+    }
+
+    bool _try_increase_cache() {
+        if (!m_dynamic_memory_allocation) {
+            return false;
+        }
+        auto device_config = m_cache_manager->get_device_config();
+        auto device = device_config->get_device();
+        size_t current_num_of_kv_blocks = m_block_manager.get_total_number_of_kv_blocks();
+        size_t new_blocks_num = current_num_of_kv_blocks * m_cache_growth_factor;
+
+        if (device.find("GPU") == std::string::npos) {
+            m_block_manager.increase_kv_blocks_number(new_blocks_num);
+        }
+        else {
+            size_t available_gpu_memory = _get_available_gpu_memory();
+            size_t required_memory = (new_blocks_num - current_num_of_kv_blocks) * device_config->get_block_size_in_bytes();
+            if (required_memory <= available_gpu_memory) {
+                m_block_manager.increase_kv_blocks_number(new_blocks_num);
+            } else {
+                size_t possible_blocks_to_add = available_gpu_memory / device_config->get_block_size_in_bytes();
+                if (possible_blocks_to_add > 0) {
+                    m_block_manager.increase_kv_blocks_number(current_num_of_kv_blocks + possible_blocks_to_add);
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
 };
 
 }
diff --git a/src/cpp/src/speculative_decoding/speculative_decoding_impl.cpp b/src/cpp/src/speculative_decoding/speculative_decoding_impl.cpp
index 46b7b106a6..257c20bf01 100644
--- a/src/cpp/src/speculative_decoding/speculative_decoding_impl.cpp
+++ b/src/cpp/src/speculative_decoding/speculative_decoding_impl.cpp
@@ -52,8 +52,7 @@ ContinuousBatchingPipeline::SpeculativeDecodingImpl::SpeculativeDecodingImpl(con
 
         size_t main_cache_size = std::ceil(main_scheduler_config.cache_size * (1.f - k)),
                draft_cache_size = main_scheduler_config.cache_size - main_cache_size;
-        OPENVINO_ASSERT(main_cache_size > 0, "KV cache model cache size should be > 0");
-        if (draft_cache_size == 0) {
+        if (draft_cache_size == 0 && main_cache_size > 0) {
             main_cache_size -= (main_cache_size > 1 ? 1 : 0);
             draft_cache_size = 1;
         }
diff --git a/src/cpp/src/utils/paged_attention_transformations.cpp b/src/cpp/src/utils/paged_attention_transformations.cpp
index 16c9556151..4dedcf989a 100644
--- a/src/cpp/src/utils/paged_attention_transformations.cpp
+++ b/src/cpp/src/utils/paged_attention_transformations.cpp
@@ -10,11 +10,6 @@ namespace ov {
 namespace genai {
 namespace utils {
 
-inline ov::PartialShape to_partial_with_dyn_0_dim(const ov::Shape& static_shape) {
-    ov::PartialShape partial_shape = static_shape;
-    partial_shape[0] = ov::Dimension::dynamic();
-    return partial_shape;
-}
 
 size_t get_hidden_size(const std::shared_ptr<ov::Model> model) {
     const auto& parameters = model->get_parameters();
@@ -65,9 +60,8 @@ void set_kv_cache_type_and_shape(std::shared_ptr<ov::Model> model, DeviceConfig&
     for (auto it_k = key_cache_params.begin(), it_v = value_cache_params.begin(); it_k != key_cache_params.end();++it_k, ++it_v) {
         it_k->second->set_element_type(device_config.get_cache_precision());
         it_v->second->set_element_type(device_config.get_cache_precision());
-        // TODO: CVS-145270
-        it_k->second->set_partial_shape(to_partial_with_dyn_0_dim(device_config.get_key_cache_shape()));
-        it_v->second->set_partial_shape(to_partial_with_dyn_0_dim(device_config.get_value_cache_shape()));
+        it_k->second->set_partial_shape(device_config.get_key_cache_shape());
+        it_v->second->set_partial_shape(device_config.get_value_cache_shape());
     }
 
     model->validate_nodes_and_infer_types();
diff --git a/tests/cpp/cache_manager.cpp b/tests/cpp/cache_manager.cpp
index b2a5396d5f..7f07980389 100644
--- a/tests/cpp/cache_manager.cpp
+++ b/tests/cpp/cache_manager.cpp
@@ -7,8 +7,43 @@
 #include "scheduler.hpp"
 #include "device_config.hpp"
 #include "cache_manager.hpp"
+#include "openvino/op/concat.hpp"
 
-TEST(TestCacheManager, general_test) {
+using namespace ov::genai;
+
+std::shared_ptr<ov::Model> get_dummy_model(size_t num_layers) {
+    ov::NodeVector keys;
+    ov::NodeVector values;
+    ov::ParameterVector params;
+    auto shape = ov::PartialShape({ov::Dimension::dynamic(), ov::Dimension::dynamic(), ov::Dimension::dynamic(), ov::Dimension::dynamic()});
+    for (size_t i = 0; i < num_layers; i++) {
+        auto key = std::make_shared<ov::op::v0::Parameter>(ov::element::f16, shape);
+        auto value = std::make_shared<ov::op::v0::Parameter>(ov::element::f16, shape);
+        key->get_output_tensor(0).set_names({"key_cache." + std::to_string(i)});
+        value->get_output_tensor(0).set_names({"value_cache." + std::to_string(i)});
+        keys.push_back(key);
+        values.push_back(value);
+        params.push_back(key);
+        params.push_back(value);
+    }
+    const auto& concat1 = std::make_shared<ov::op::v0::Concat>(keys, 1);
+    const auto& concat2 = std::make_shared<ov::op::v0::Concat>(values, 1);
+    auto model = std::make_shared<ov::Model>(ov::NodeVector{concat1, concat2}, params);
+    return std::make_shared<ov::Model>(ov::NodeVector{concat1, concat2}, params);
+}
+
+size_t get_total_allocated_bytes(std::shared_ptr<ov::genai::CacheManager> cache_manager, size_t num_decoder_layers) {
+    size_t allocated_bytes = 0;
+    for (size_t i = 0; i < num_decoder_layers; i++) {
+        auto key_cache = cache_manager->get_key_cache(i);
+        auto value_cache = cache_manager->get_value_cache(i);
+        allocated_bytes += key_cache.get_byte_size() + value_cache.get_byte_size();
+    }
+    return allocated_bytes;
+}
+
+
+TEST(TestCacheManager, test_cache_size_param) {
     ov::Core core;
     ov::genai::SchedulerConfig scheduler_config;
     scheduler_config.max_num_batched_tokens = 32;
@@ -21,14 +56,73 @@ TEST(TestCacheManager, general_test) {
     size_t num_decoder_layers = 12;
     device_config.set_model_params(12, 64, num_decoder_layers);
 
-    auto cache_manager = std::make_shared<ov::genai::CacheManager>(device_config, core);
-
-    size_t allocated_bytes = 0;
-    for (size_t i = 0; i < num_decoder_layers; i++) {
-        auto key_cache = cache_manager->get_key_cache(i);
-        auto value_cache = cache_manager->get_value_cache(i);
-        allocated_bytes += key_cache.get_byte_size() + value_cache.get_byte_size();
-    }
+    ov::InferRequest request = core.compile_model(get_dummy_model(num_decoder_layers)).create_infer_request();
+    auto cache_manager = std::make_shared<ov::genai::CacheManager>(device_config, request, core);
+    auto block_manager = BlockManager(device_config.get_num_kv_blocks(), false, device_config.get_block_size(), device_config.get_num_layers());
+    cache_manager->allocate_cache_if_needed(block_manager.get_total_number_of_kv_blocks());
     
-    ASSERT_EQ(allocated_bytes, 2146959360);
+    ASSERT_EQ(get_total_allocated_bytes(cache_manager, num_decoder_layers), 2146959360);
 }
+
+
+TEST(TestCacheManager, test_kv_blocks_param) {
+    ov::Core core;
+    ov::genai::SchedulerConfig scheduler_config;
+    scheduler_config.max_num_batched_tokens = 32;
+    scheduler_config.num_kv_blocks = 150;
+    scheduler_config.cache_size = 0;
+    scheduler_config.max_num_seqs = 2;
+
+    const std::string device = "CPU";
+    ov::genai::DeviceConfig device_config(core, scheduler_config, "CPU");
+    size_t num_decoder_layers = 12;
+    device_config.set_model_params(12, 64, num_decoder_layers);
+
+    ov::InferRequest request = core.compile_model(get_dummy_model(num_decoder_layers)).create_infer_request();
+    auto cache_manager = std::make_shared<ov::genai::CacheManager>(device_config, request, core);
+    auto block_manager = BlockManager(device_config.get_num_kv_blocks(), false, device_config.get_block_size(), device_config.get_num_layers());
+    OPENVINO_ASSERT(block_manager.get_total_number_of_kv_blocks(), scheduler_config.num_kv_blocks);
+}
+
+
+TEST(TestCacheManager, test_dynamic_cache_increase) {
+    ov::Core core;
+    ov::genai::SchedulerConfig scheduler_config;
+    scheduler_config.max_num_batched_tokens = 32;
+    scheduler_config.num_kv_blocks = 0;
+    scheduler_config.cache_size = 0;
+    scheduler_config.max_num_seqs = 2;
+
+    const std::string device = "CPU";
+    ov::genai::DeviceConfig device_config(core, scheduler_config, "CPU");
+    size_t num_decoder_layers = 12;
+    size_t head_size = 64;
+    size_t num_kv_heads = 12;
+    device_config.set_model_params(num_kv_heads, head_size, num_decoder_layers);
+    size_t block_size_in_bytes = num_decoder_layers * 2 * num_kv_heads * device_config.get_block_size() * head_size * device_config.get_cache_precision().size();
+
+
+    ov::InferRequest request = core.compile_model(get_dummy_model(num_decoder_layers)).create_infer_request();
+    auto cache_manager = std::make_shared<ov::genai::CacheManager>(device_config, request, core);
+    auto block_manager = BlockManager(device_config.get_num_kv_blocks(), false, device_config.get_block_size(), device_config.get_num_layers());
+
+    // check initial cache allocation
+    block_manager.increase_kv_blocks_number(100);
+    OPENVINO_ASSERT(block_manager.get_total_number_of_kv_blocks(), 100);
+
+    cache_manager->allocate_cache_if_needed(block_manager.get_total_number_of_kv_blocks());
+    OPENVINO_ASSERT(get_total_allocated_bytes(cache_manager, num_decoder_layers), 100 * block_size_in_bytes);
+
+
+    // check cache increase
+    block_manager.increase_kv_blocks_number(200);
+    OPENVINO_ASSERT(block_manager.get_total_number_of_kv_blocks(), 200);
+
+    cache_manager->allocate_cache_if_needed(block_manager.get_total_number_of_kv_blocks());
+    OPENVINO_ASSERT(get_total_allocated_bytes(cache_manager, num_decoder_layers), 200 * block_size_in_bytes);
+
+
+    // check that cache does not increase if new blocks were not allocated
+    cache_manager->allocate_cache_if_needed(block_manager.get_total_number_of_kv_blocks());
+    OPENVINO_ASSERT(get_total_allocated_bytes(cache_manager, num_decoder_layers), 200 * block_size_in_bytes);
+}
\ No newline at end of file
diff --git a/tests/cpp/scheduler.cpp b/tests/cpp/scheduler.cpp
index 40c3e73747..ea1720faa2 100644
--- a/tests/cpp/scheduler.cpp
+++ b/tests/cpp/scheduler.cpp
@@ -4,6 +4,7 @@
 
 #include <gtest/gtest.h>
 #include "openvino/runtime/core.hpp"
+#include "openvino/op/concat.hpp"
 #include "openvino/genai/continuous_batching_pipeline.hpp"
 #include "openvino/genai/generation_config.hpp"
 #include "sequence_group.hpp"
@@ -17,6 +18,37 @@ void clear_finished_sequences(std::vector<SequenceGroup::Ptr>& requests) {
     });
     requests.erase(new_end, requests.end());
 }
+std::shared_ptr<ov::Model> get_model(size_t num_layers) {
+    ov::NodeVector keys;
+    ov::NodeVector values;
+    ov::ParameterVector params;
+    auto shape = ov::PartialShape({ov::Dimension::dynamic(), ov::Dimension::dynamic(), ov::Dimension::dynamic(), ov::Dimension::dynamic()});
+    for (size_t i = 0; i < num_layers; i++) {
+        auto key = std::make_shared<ov::op::v0::Parameter>(ov::element::f16, shape);
+        auto value = std::make_shared<ov::op::v0::Parameter>(ov::element::f16, shape);
+        key->get_output_tensor(0).set_names({"key_cache." + std::to_string(i)});
+        value->get_output_tensor(0).set_names({"value_cache." + std::to_string(i)});
+        keys.push_back(key);
+        values.push_back(value);
+        params.push_back(key);
+        params.push_back(value);
+    }
+    const auto& concat1 = std::make_shared<ov::op::v0::Concat>(keys, 1);
+    const auto& concat2 = std::make_shared<ov::op::v0::Concat>(values, 1);
+    auto model = std::make_shared<ov::Model>(ov::NodeVector{concat1, concat2}, params);
+    return std::make_shared<ov::Model>(ov::NodeVector{concat1, concat2}, params);
+}
+
+std::shared_ptr<CacheManager> init_cache_manager(SchedulerConfig scheduler_config) {
+    ov::Core core = ov::Core();
+    size_t num_decoder_layers = 12;
+    ov::InferRequest request = core.compile_model(get_model(num_decoder_layers)).create_infer_request();
+    size_t head_size = 64, head_size_u8 = head_size + 8;
+    size_t num_kv_heads = 12;
+    ov::genai::DeviceConfig device_config(core, scheduler_config, "CPU");
+    device_config.set_model_params(num_kv_heads, head_size_u8, num_decoder_layers);
+    return std::make_shared<CacheManager>(device_config, request, core);  
+}
 
 TEST(TestScheduler, general_test) {
     std::array<SchedulerConfig, 2> configs = {SchedulerConfig(), SchedulerConfig()};
@@ -40,10 +72,9 @@ TEST(TestScheduler, general_test) {
                                                                                 ov::genai::greedy(), 4, scheduler_config.enable_prefix_caching);
         auto idx2 = (*sequence_group3)[0]->get_id();
         std::vector<SequenceGroup::Ptr> requests = {sequence_group1, sequence_group2, sequence_group3};
-                                                                        
         
         // schedule 3 sequence groups that use 6 kv blocks 
-        Scheduler scheduler = Scheduler(4, scheduler_config);
+        Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
         auto out1 = scheduler.schedule(requests);
 
         std::vector<uint64_t> ref_ids = {0, 1, 2};
@@ -144,7 +175,7 @@ TEST_P(AppendSlotsSchedulerTest, test_append_slots_considers_all_sequences) {
     auto idx1 = (*sequence_group2)[0]->get_id();
     std::vector<SequenceGroup::Ptr> requests = {sequence_group1, sequence_group2};
 
-    Scheduler scheduler = Scheduler(4, scheduler_config);
+    Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
     auto out1 = scheduler.schedule(requests);
 
     std::vector<uint64_t> ref_ids = {0, 1};
@@ -212,7 +243,7 @@ TEST_P(PartialPreemptionSchedulerTest, test_partial_preemption) {
 
 
     // schedule 2 sequence groups that use 5 kv blocks
-    Scheduler scheduler = Scheduler(4, scheduler_config);
+    Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
     auto out0 = scheduler.schedule(requests);
 
     for (auto seq: requests) {
@@ -297,7 +328,7 @@ TEST(TestScheduler, test_partial_preemption_beam_search) {
         sequence_group->set_sequence_group_ptr(sequence_group);
         std::vector<SequenceGroup::Ptr> requests = {sequence_group};
 
-        Scheduler scheduler = Scheduler(4, scheduler_config);
+        Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
         auto out = scheduler.schedule(requests);
         for (auto sequence: sequence_group->get_not_finished_sequences()) {
             sequence->append_token(token, 0.7);
@@ -405,11 +436,10 @@ TEST(TestScheduler, test_partially_preempted_prompt) {
         SequenceGroup::Ptr sequence_group2 = std::make_shared<SequenceGroup>(1, ov::Tensor(ov::element::i64, {tokens.size()}, tokens.data()),
                                                                                 ov::genai::greedy(), 4, scheduler_config.enable_prefix_caching);
         auto idx1 = (*sequence_group2)[0]->get_id();
-        std::vector<SequenceGroup::Ptr> requests = {sequence_group1, sequence_group2};
-                                                                        
+        std::vector<SequenceGroup::Ptr> requests = {sequence_group1, sequence_group2};                                                
         
         // schedule 2 sequence groups that use all available 2*3 kv blocks, we used all available kv-blocks.
-        Scheduler scheduler = Scheduler(4, scheduler_config);
+        Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
         auto out1 = scheduler.schedule(requests);
 
         for (auto seq: requests) {
@@ -503,7 +533,7 @@ TEST(TestScheduler, prefix_caching_test) {
         std::vector<uint64_t> prompt_tokens = {0,1,2,3,4,5,6,7};
         std::vector<uint64_t> histrory_tokens = {};
         // schedule prompt
-        Scheduler scheduler = Scheduler(4, scheduler_config);
+        Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
 
         size_t chat_iterations = 10;
 
@@ -566,7 +596,7 @@ TEST(TestScheduler, prefix_caching_test_two_identical_sequences) {
         std::vector<uint64_t> prompt_tokens = {0,1,2,3,4,5,6,7};
         std::vector<uint64_t> histrory_tokens = {};
         // schedule prompt
-        Scheduler scheduler = Scheduler(4, scheduler_config);
+        Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config);
 
         size_t chat_iterations = 10;
 
@@ -640,7 +670,7 @@ TEST(TestScheduler, prefix_caching_with_max_new_tokens_equal_1) {
     for (auto scheduler_config: configs) {
         std::vector<uint64_t> prompt_tokens = {0,1,2,3,4,5,6,7};
         // schedule prompt
-        Scheduler scheduler = Scheduler(32, scheduler_config);
+        Scheduler scheduler = Scheduler(32, init_cache_manager(scheduler_config), scheduler_config);
 
         size_t chat_iterations = 2;
 
@@ -701,7 +731,7 @@ TEST(TestScheduler, test_partially_preempted_prompt_not_allowed) {
 
     // schedule 2 sequence groups that use all available 2*3 kv blocks, we used all available kv-blocks.
     const bool can_use_partial_preemption = false;
-    Scheduler scheduler = Scheduler(4, scheduler_config, 1, can_use_partial_preemption);
+    Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config, 1, can_use_partial_preemption);
     auto out1 = scheduler.schedule(requests);
 
     for (auto req : requests)
@@ -775,7 +805,7 @@ TEST(TestScheduler, test_partially_preempted_prompt_not_allowed2) {
 
     // schedule 2 sequence groups that use all available 2*3 kv blocks, we used all available kv-blocks.
     const bool can_use_partial_preemption = false;
-    Scheduler scheduler = Scheduler(4, scheduler_config, 1, can_use_partial_preemption);
+    Scheduler scheduler = Scheduler(4, init_cache_manager(scheduler_config), scheduler_config, 1, can_use_partial_preemption);
     scheduler.schedule(requests);
     for (auto req: requests)
         req->finish_iteration();
@@ -874,7 +904,6 @@ TEST(TestScheduler, FullyPreemptsCacheEvictedSequences) {
     scheduler_config.use_cache_eviction = true;
     scheduler_config.cache_eviction_config = ov::genai::CacheEvictionConfig(2, 2, 6, ov::genai::AggregationMode::NORM_SUM);
 
-
     std::vector<uint64_t> tokens1 = {0, 1};  // 1 full block
     SequenceGroup::Ptr sequence_group1 = std::make_shared<SequenceGroup>(0,
                                                                          ov::Tensor(ov::element::i64, {tokens1.size()},
@@ -890,7 +919,7 @@ TEST(TestScheduler, FullyPreemptsCacheEvictedSequences) {
     std::vector<SequenceGroup::Ptr> requests = {sequence_group1, sequence_group2};
 
 
-    Scheduler scheduler = Scheduler(2, scheduler_config);
+    Scheduler scheduler = Scheduler(2, init_cache_manager(scheduler_config), scheduler_config);
     // prompt phase - schedules 1 block for seq 1, 5 blocks for seq 2
     auto out = scheduler.schedule(requests);
 
diff --git a/tests/python_tests/common.py b/tests/python_tests/common.py
index 163a00192e..cf5fbb3403 100644
--- a/tests/python_tests/common.py
+++ b/tests/python_tests/common.py
@@ -266,7 +266,6 @@ def get_test_dataset() -> Tuple[List[str], List[GenerationConfig]]:
 
 def get_scheduler_config(scheduler_params: dict = None) -> SchedulerConfig:
     scheduler_config = SchedulerConfig()
-    scheduler_config.cache_size = 1
     if scheduler_params is None:
         scheduler_config.dynamic_split_fuse = True
         # vLLM specific
diff --git a/tests/python_tests/ov_genai_test_utils.py b/tests/python_tests/ov_genai_test_utils.py
index b633497d32..5f2702a774 100644
--- a/tests/python_tests/ov_genai_test_utils.py
+++ b/tests/python_tests/ov_genai_test_utils.py
@@ -283,5 +283,4 @@ def load_pipe(configs: List[Tuple], temp_path):
 @functools.lru_cache(1)
 def get_continuous_batching(path):
     scheduler_config = ov_genai.SchedulerConfig()
-    scheduler_config.cache_size = 1
     return ov_genai.LLMPipeline(path, ov_genai.Tokenizer(path), 'CPU', **{"scheduler_config": scheduler_config})
diff --git a/tests/python_tests/test_cache_optimizations.py b/tests/python_tests/test_cache_optimizations.py
index 45704f9dc6..3c09d34756 100644
--- a/tests/python_tests/test_cache_optimizations.py
+++ b/tests/python_tests/test_cache_optimizations.py
@@ -15,7 +15,7 @@
 from openvino import serialize
 from transformers import AutoTokenizer
 
-from common import TESTS_ROOT
+from common import TESTS_ROOT, run_test_pipeline
 
 
 def load_prompts_dataset(file_name : str) -> Dict[str, List[str]]:
@@ -145,3 +145,28 @@ def test_cache_optimized_generation_is_similar_to_unoptimized(converted_model, t
     del model_cb_noopt
 
 
+def get_greedy_seq_len_300() -> GenerationConfig:
+    generation_config = GenerationConfig()
+    generation_config.num_return_sequences = 3
+    generation_config.max_new_tokens = 300
+    return generation_config
+
+def get_beam_search_seq_len_300() -> GenerationConfig:
+    generation_config = GenerationConfig()
+    generation_config.num_beam_groups = 3
+    generation_config.num_beams = 6
+    generation_config.max_new_tokens = 300
+    generation_config.num_return_sequences = generation_config.num_beams
+    return generation_config
+
+scheduler_params_list = [
+                         ({"num_kv_blocks": 0, "cache_size": 0, "dynamic_split_fuse": True, "enable_prefix_caching": True}, get_greedy_seq_len_300()),
+                         ({"num_kv_blocks": 0, "cache_size": 0, "dynamic_split_fuse": False, "max_num_batched_tokens": 600, "enable_prefix_caching": True}, get_beam_search_seq_len_300()),
+                         ({"num_kv_blocks": 0, "cache_size": 0, "dynamic_split_fuse": True, "enable_prefix_caching": False}, get_greedy_seq_len_300()),
+                         ({"num_kv_blocks": 0, "cache_size": 0, "dynamic_split_fuse": False, "max_num_batched_tokens": 600, "enable_prefix_caching": False}, get_beam_search_seq_len_300()),
+                         ({"num_kv_blocks": 0, "cache_size": 0, "dynamic_split_fuse": False, "max_num_batched_tokens": 600, "use_cache_eviction": True, "cache_eviction_config": SHORT_CACHE_EVICTION_CONFIG}, get_greedy_seq_len_300())]
+@pytest.mark.parametrize("params", scheduler_params_list)
+@pytest.mark.precommit
+def test_dynamic_memory_allocation(tmp_path, params):
+    run_test_pipeline(tmp_path, "facebook/opt-125m", params[0], params[1])
+