diff --git a/opencl/source/program/create.inl b/opencl/source/program/create.inl
index 4d44f66725..df5321af1b 100644
--- a/opencl/source/program/create.inl
+++ b/opencl/source/program/create.inl
@@ -6,6 +6,7 @@
  */
 
 #include "shared/source/ail/ail_configuration.h"
+#include "shared/source/execution_environment/root_device_environment.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/string_helpers.h"
 
@@ -71,8 +72,7 @@ T *Program::create(
 
     if (CL_SUCCESS == retVal) {
 
-        auto &hwInfo = pContext->getDevice(0)->getHardwareInfo();
-        auto ail = AILConfiguration::get(hwInfo.platform.eProductFamily);
+        auto ail = pContext->getDevice(0)->getRootDeviceEnvironment().getAILConfigurationHelper();
         if (ail) {
             ail->modifyKernelIfRequired(combinedString);
         }
diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp
index ae657d6450..99c0be5ece 100644
--- a/opencl/test/unit_test/program/program_tests.cpp
+++ b/opencl/test/unit_test/program/program_tests.cpp
@@ -680,10 +680,10 @@ void MinimumProgramFixture::TearDown() {
     NEO::PlatformFixture::tearDown();
 }
 
-TEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange) {
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    ailConfigurationTable[productFamily] = nullptr;
+HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange, IsDG2) {
+    auto pDevice = pContext->getDevice(0);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
     const char *sources[] = {"kernel() {}"};
     size_t knownSourceSize = strlen(sources[0]);
 
@@ -701,9 +701,10 @@ TEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourc
     pProgram->release();
 }
 
-HWTEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesAndWithDummyKernelThenDoNotMarkApplicationContextAsNonZebin) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    ailConfigurationTable[productFamily] = nullptr;
+HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesAndWithDummyKernelThenDoNotMarkApplicationContextAsNonZebin, IsAtLeastSkl) {
+    auto pDevice = pContext->getDevice(0);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
     const char *dummyKernelSources[] = {"kernel void _(){}"}; // if detected - should trigger fallback to CTNI
     size_t knownSourceSize = strlen(dummyKernelSources[0]);
 
@@ -754,10 +755,10 @@ HWTEST2_F(MinimumProgramFixture, givenAILReturningTrueForFallbackRequirementWhen
             return true;
         }
     };
-    VariableBackup<AILConfiguration *> ailConfiguration(&ailConfigurationTable[productFamily]);
+    auto pDevice = pContext->getDevice(0);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(new MockAIL());
 
-    MockAIL mockAIL;
-    ailConfigurationTable[productFamily] = &mockAIL;
     ASSERT_FALSE(pContext->checkIfContextIsNonZebin());
 
     const char *kernelSources[] = {"some source code"};
diff --git a/shared/source/ail/ail_configuration.h b/shared/source/ail/ail_configuration.h
index 9fa8143dba..3877dd558d 100644
--- a/shared/source/ail/ail_configuration.h
+++ b/shared/source/ail/ail_configuration.h
@@ -10,6 +10,7 @@
 #include "igfxfmid.h"
 
 #include <cstdint>
+#include <memory>
 #include <set>
 #include <string>
 
@@ -43,14 +44,24 @@ enum class AILEnumeration : uint32_t {
     AIL_MAX_OPTIONS_COUNT
 };
 
+class AILConfiguration;
+using AILConfigurationCreateFunctionType = std::unique_ptr<AILConfiguration> (*)();
+extern AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
+
 class AILConfiguration {
   public:
+    static std::unique_ptr<AILConfiguration> create(PRODUCT_FAMILY product) {
+        auto ailConfigurationCreateFunction = ailConfigurationFactory[product];
+        if (ailConfigurationCreateFunction == nullptr) {
+            return nullptr;
+        }
+        auto ailConfiguration = ailConfigurationCreateFunction();
+        return ailConfiguration;
+    }
     AILConfiguration() = default;
 
     MOCKABLE_VIRTUAL bool initProcessExecutableName();
 
-    static AILConfiguration *get(PRODUCT_FAMILY productFamily);
-
     virtual void apply(RuntimeCapabilityTable &runtimeCapabilityTable);
 
     virtual void modifyKernelIfRequired(std::string &kernel) = 0;
@@ -59,6 +70,8 @@ class AILConfiguration {
 
     virtual bool isContextSyncFlagRequired() = 0;
 
+    virtual ~AILConfiguration() = default;
+
   protected:
     virtual void applyExt(RuntimeCapabilityTable &runtimeCapabilityTable) = 0;
     std::string processName;
@@ -67,15 +80,13 @@ class AILConfiguration {
     MOCKABLE_VIRTUAL bool isKernelHashCorrect(const std::string &kernelSources, uint64_t expectedHash) const;
 };
 
-extern AILConfiguration *ailConfigurationTable[IGFX_MAX_PRODUCT];
-
 extern const std::set<std::string_view> applicationsContextSyncFlag;
 
 template <PRODUCT_FAMILY Product>
 class AILConfigurationHw : public AILConfiguration {
   public:
-    static AILConfigurationHw<Product> &get() {
-        static AILConfigurationHw<Product> ailConfiguration;
+    static std::unique_ptr<AILConfiguration> create() {
+        auto ailConfiguration = std::unique_ptr<AILConfiguration>(new AILConfigurationHw());
         return ailConfiguration;
     }
 
@@ -89,7 +100,8 @@ class AILConfigurationHw : public AILConfiguration {
 template <PRODUCT_FAMILY product>
 struct EnableAIL {
     EnableAIL() {
-        ailConfigurationTable[product] = &AILConfigurationHw<product>::get();
+        auto ailConfigurationCreateFunction = AILConfigurationHw<product>::create;
+        ailConfigurationFactory[product] = ailConfigurationCreateFunction;
     }
 };
 
diff --git a/shared/source/ail/ail_configuration_extra.cpp b/shared/source/ail/ail_configuration_extra.cpp
index 84db3030d9..160b7a5324 100644
--- a/shared/source/ail/ail_configuration_extra.cpp
+++ b/shared/source/ail/ail_configuration_extra.cpp
@@ -28,11 +28,7 @@ std::map<std::string_view, std::vector<AILEnumeration>> applicationMapMTL = {{"s
 
 const std::set<std::string_view> applicationsContextSyncFlag = {};
 
-AILConfiguration *ailConfigurationTable[IGFX_MAX_PRODUCT] = {};
-
-AILConfiguration *AILConfiguration::get(PRODUCT_FAMILY productFamily) {
-    return ailConfigurationTable[productFamily];
-}
+AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
 
 void AILConfiguration::apply(RuntimeCapabilityTable &runtimeCapabilityTable) {
     auto search = applicationMap.find(processName);
diff --git a/shared/source/execution_environment/root_device_environment.cpp b/shared/source/execution_environment/root_device_environment.cpp
index 083912d6bd..e922742f12 100644
--- a/shared/source/execution_environment/root_device_environment.cpp
+++ b/shared/source/execution_environment/root_device_environment.cpp
@@ -101,11 +101,6 @@ void RootDeviceEnvironment::prepareForCleanup() const {
 }
 
 bool RootDeviceEnvironment::initAilConfiguration() {
-    if (!DebugManager.flags.EnableAIL.get()) {
-        return true;
-    }
-    auto ailConfiguration = AILConfiguration::get(hwInfo->platform.eProductFamily);
-
     if (ailConfiguration == nullptr) {
         return true;
     }
@@ -161,6 +156,7 @@ void RootDeviceEnvironment::initHelpers() {
     initApiGfxCoreHelper();
     initCompilerProductHelper();
     initReleaseHelper();
+    initAilConfigurationHelper();
 }
 
 void RootDeviceEnvironment::initGfxCoreHelper() {
@@ -186,10 +182,20 @@ void RootDeviceEnvironment::initReleaseHelper() {
     }
 }
 
+void RootDeviceEnvironment::initAilConfigurationHelper() {
+    if (ailConfiguration == nullptr && DebugManager.flags.EnableAIL.get()) {
+        ailConfiguration = AILConfiguration::create(this->getHardwareInfo()->platform.eProductFamily);
+    }
+}
+
 ReleaseHelper *RootDeviceEnvironment::getReleaseHelper() const {
     return releaseHelper.get();
 }
 
+AILConfiguration *RootDeviceEnvironment::getAILConfigurationHelper() const {
+    return ailConfiguration.get();
+}
+
 BuiltIns *RootDeviceEnvironment::getBuiltIns() {
     if (this->builtins.get() == nullptr) {
         std::lock_guard<std::mutex> autolock(this->mtx);
diff --git a/shared/source/execution_environment/root_device_environment.h b/shared/source/execution_environment/root_device_environment.h
index 294dbf973d..ca6f6580eb 100644
--- a/shared/source/execution_environment/root_device_environment.h
+++ b/shared/source/execution_environment/root_device_environment.h
@@ -40,6 +40,7 @@ class ApiGfxCoreHelper;
 class CompilerProductHelper;
 class GraphicsAllocation;
 class ReleaseHelper;
+class AILConfiguration;
 
 struct AllocationProperties;
 struct HardwareInfo;
@@ -85,7 +86,9 @@ struct RootDeviceEnvironment : NonCopyableClass {
     void initApiGfxCoreHelper();
     void initCompilerProductHelper();
     void initReleaseHelper();
+    void initAilConfigurationHelper();
     ReleaseHelper *getReleaseHelper() const;
+    AILConfiguration *getAILConfigurationHelper() const;
     template <typename HelperType>
     HelperType &getHelper() const;
     const ProductHelper &getProductHelper() const;
@@ -108,6 +111,7 @@ struct RootDeviceEnvironment : NonCopyableClass {
     std::unique_ptr<ProductHelper> productHelper;
     std::unique_ptr<CompilerProductHelper> compilerProductHelper;
     std::unique_ptr<ReleaseHelper> releaseHelper;
+    std::unique_ptr<AILConfiguration> ailConfiguration;
 
     std::unique_ptr<AssertHandler> assertHandler;
 
diff --git a/shared/test/common/mocks/mock_ail_configuration.h b/shared/test/common/mocks/mock_ail_configuration.h
index dd85413d2b..13194341b1 100644
--- a/shared/test/common/mocks/mock_ail_configuration.h
+++ b/shared/test/common/mocks/mock_ail_configuration.h
@@ -13,10 +13,8 @@ namespace NEO {
 class MockAILConfiguration : public AILConfiguration {
   public:
     bool initProcessExecutableName() override {
-        initCalled = true;
         return true;
     }
-    bool initCalled = false;
     void modifyKernelIfRequired(std::string &kernel) override {}
 
     bool isFallbackToPatchtokensRequired(const std::string &kernelSources) override {
@@ -33,7 +31,7 @@ class MockAILConfiguration : public AILConfiguration {
 };
 
 template <PRODUCT_FAMILY productFamily>
-class AILMock : public AILConfigurationHw<productFamily> {
+class AILWhitebox : public AILConfigurationHw<productFamily> {
   public:
     using AILConfiguration::apply;
     using AILConfiguration::isKernelHashCorrect;
diff --git a/shared/test/unit_test/ail/ail_tests.cpp b/shared/test/unit_test/ail/ail_tests.cpp
index e2002673b0..6e5fb8bf15 100644
--- a/shared/test/unit_test/ail/ail_tests.cpp
+++ b/shared/test/unit_test/ail/ail_tests.cpp
@@ -19,54 +19,37 @@ using IsHostPtrTrackingDisabled = IsWithinGfxCore<IGFX_GEN9_CORE, IGFX_GEN11LP_C
 
 using AILTests = ::testing::Test;
 
-HWTEST2_F(AILTests, givenInitializedTemplateWhenGetAILConfigurationThenNullptrIsNotReturned, IsSKL) {
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    EXPECT_NE(nullptr, ailConfiguration);
+TEST(AILTests, whenAILConfigurationCreateFunctionIsCalledWithUnknownGfxCoreThenNullptrIsReturned) {
+    EXPECT_EQ(nullptr, AILConfiguration::create(IGFX_UNKNOWN));
 }
 
 HWTEST2_F(AILTests, givenInitilizedTemplateWhenApplyWithBlenderIsCalledThenFP64SupportIsEnabled, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "blender";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
+    ail.processName = "blender";
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.ftrSupportsFP64 = false;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_EQ(rtTable.ftrSupportsFP64, true);
 }
 
 HWTEST2_F(AILTests, givenInitilizedTemplateWhenApplyWithAdobePremiereProIsCalledThenPreferredPlatformNameIsSet, IsAtLeastGen9) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "Adobe Premiere Pro";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
+    ail.processName = "Adobe Premiere Pro";
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.preferredPlatformName = nullptr;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_NE(nullptr, rtTable.preferredPlatformName);
     EXPECT_STREQ("Intel(R) OpenCL", rtTable.preferredPlatformName);
 }
 
 HWTEST2_F(AILTests, whenCheckingIfSourcesContainKernelThenCorrectResultIsReturned, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
 
     std::string kernelSources = R"( 
 __kernel void CopyBufferToBufferLeftLeftover(
@@ -96,11 +79,7 @@ __kernel void CopyBufferToBufferMiddle(
 }
 
 HWTEST2_F(AILTests, whenCheckingIsKernelHashCorrectThenCorrectResultIsReturned, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
 
     std::string kernelSources = R"( 
 __kernel void CopyBufferToBufferLeftLeftover(
@@ -125,11 +104,7 @@ __kernel void CopyBufferToBufferLeftLeftover(
 }
 
 HWTEST2_F(AILTests, whenModifyKernelIfRequiredIsCalledThenDontChangeKernelSources, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
 
     std::string kernelSources = "example_kernel(){}";
     auto copyKernel = kernelSources;
@@ -140,99 +115,48 @@ HWTEST2_F(AILTests, whenModifyKernelIfRequiredIsCalledThenDontChangeKernelSource
 }
 
 HWTEST2_F(AILTests, givenPreGen12AndProcessNameIsResolveWhenApplyWithDavinciResolveThenHostPtrTrackingIsDisabled, IsHostPtrTrackingDisabled) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "resolve";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
+    ail.processName = "resolve";
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.hostPtrTrackingEnabled = true;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_FALSE(rtTable.hostPtrTrackingEnabled);
 }
 
 HWTEST2_F(AILTests, givenPreGen12AndAndProcessNameIsNotResolveWhenApplyWithDavinciResolveThenHostPtrTrackingIsEnabled, IsHostPtrTrackingDisabled) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "usualProcessName";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
+    AILWhitebox<productFamily> ail;
+    ail.processName = "usualProcessName";
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.hostPtrTrackingEnabled = true;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_TRUE(rtTable.hostPtrTrackingEnabled);
 }
 
-HWTEST_F(AILTests, whenAilIsDisabledByDebugVariableThenAilIsNotInitialized) {
-    DebugManagerStateRestore restore;
-    NEO::DebugManager.flags.EnableAIL.set(false);
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    MockAILConfiguration ailConfig;
-    ailConfigurationTable[productFamily] = &ailConfig;
-
-    HardwareInfo hwInfo{};
-    hwInfo.platform.eProductFamily = productFamily;
-    hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
-
-    NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
-    auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
-    rootDeviceEnvironment->initAilConfiguration();
-
-    EXPECT_EQ(false, ailConfig.initCalled);
-}
-
-HWTEST_F(AILTests, whenAilIsEnabledByDebugVariableThenAilIsInitialized) {
-    DebugManagerStateRestore restore;
-    NEO::DebugManager.flags.EnableAIL.set(true);
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    MockAILConfiguration ailConfig;
-    ailConfigurationTable[productFamily] = &ailConfig;
-
-    HardwareInfo hwInfo{};
-    hwInfo.platform.eProductFamily = productFamily;
-    hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
-
-    NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
-    auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
-    rootDeviceEnvironment->initAilConfiguration();
-
-    EXPECT_EQ(true, ailConfig.initCalled);
-}
-
 HWTEST_F(AILTests, GivenPlatformHasNoAilAvailableWhenAilIsEnabledThenAilInitializationReturnsTrue) {
     DebugManagerStateRestore restore;
     NEO::DebugManager.flags.EnableAIL.set(true);
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    ailConfigurationTable[productFamily] = nullptr;
-
     HardwareInfo hwInfo{};
     hwInfo.platform.eProductFamily = productFamily;
     hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
 
     NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
     auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
+
     EXPECT_TRUE(rootDeviceEnvironment->initAilConfiguration());
 }
 
 HWTEST2_F(AILTests, GivenAilWhenCheckingContextSyncFlagRequiredThenExpectFalse, IsAtLeastGen9) {
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "other";
-    EXPECT_FALSE(ailTemp.isContextSyncFlagRequired());
+    AILWhitebox<productFamily> ail;
+    ail.processName = "other";
+    EXPECT_FALSE(ail.isContextSyncFlagRequired());
 }
 
 } // namespace NEO
diff --git a/shared/test/unit_test/ail/ail_tests_base.cpp b/shared/test/unit_test/ail/ail_tests_base.cpp
index 4e447530a2..352d707812 100644
--- a/shared/test/unit_test/ail/ail_tests_base.cpp
+++ b/shared/test/unit_test/ail/ail_tests_base.cpp
@@ -5,9 +5,9 @@
  *
  */
 
-#include "shared/source/ail/ail_configuration.h"
 #include "shared/test/common/helpers/default_hw_info.h"
 #include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
 namespace NEO {
@@ -27,15 +27,7 @@ HWTEST2_F(AILBaseTests, whenKernelSourceIsNotANGenDummyKernelThenDoNotEnforcePat
 }
 
 HWTEST2_F(AILBaseTests, givenApplicationNamesThatRequirAILWhenCheckingIfPatchtokenFallbackIsRequiredThenIsCorrectResult, IsAtLeastSkl) {
-    class AILMock : public AILConfigurationHw<productFamily> {
-      public:
-        using AILConfiguration::processName;
-    };
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock ail;
-    ailConfigurationTable[productFamily] = &ail;
-
+    AILWhitebox<productFamily> ail;
     for (const auto &name : {"Resolve",
                              "ArcControlAssist",
                              "ArcControl"}) {
diff --git a/shared/test/unit_test/ail/windows/ail_windows_tests.cpp b/shared/test/unit_test/ail/windows/ail_windows_tests.cpp
index 93d25433ae..b6af6da27c 100644
--- a/shared/test/unit_test/ail/windows/ail_windows_tests.cpp
+++ b/shared/test/unit_test/ail/windows/ail_windows_tests.cpp
@@ -1,13 +1,13 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
-#include "shared/source/ail/ail_configuration.h"
 #include "shared/test/common/helpers/unit_test_helper.h"
 #include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
 namespace NEO {
@@ -17,52 +17,37 @@ namespace SysCalls {
 extern const wchar_t *currentLibraryPath;
 }
 
-template <PRODUCT_FAMILY productFamily>
-class AILMock : public AILConfigurationHw<productFamily> {
-  public:
-    using AILConfiguration::processName;
-};
-
 HWTEST2_F(AILTests, givenValidApplicationPathWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\Users\\Administrator\\application.exe";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
-    ailConfigurationTable[productFamily] = &ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
-
-    EXPECT_EQ("application", ailTemp.processName);
+    EXPECT_EQ("application", ail.processName);
 }
 
 HWTEST2_F(AILTests, givenValidApplicationPathWithoutLongNameWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\Users\\Administrator\\application";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
-    ailConfigurationTable[productFamily] = &ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
-
-    EXPECT_EQ("application", ailTemp.processName);
+    EXPECT_EQ("application", ail.processName);
 }
 
 HWTEST2_F(AILTests, givenApplicationPathWithNonLatinCharactersWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\\u4E20\u4E24\\application";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
-    ailConfigurationTable[productFamily] = &ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
-
-    EXPECT_EQ("application", ailTemp.processName);
+    EXPECT_EQ("application", ail.processName);
 }
 
 } // namespace NEO
diff --git a/shared/test/unit_test/execution_environment/execution_environment_tests.cpp b/shared/test/unit_test/execution_environment/execution_environment_tests.cpp
index f949a2c804..50956d83e4 100644
--- a/shared/test/unit_test/execution_environment/execution_environment_tests.cpp
+++ b/shared/test/unit_test/execution_environment/execution_environment_tests.cpp
@@ -207,6 +207,17 @@ TEST(RootDeviceEnvironment, givenHardwareInfoAndDebugVariableNodeOrdinalEqualsCc
     EXPECT_TRUE(hwInfo->featureTable.flags.ftrRcsNode);
 }
 
+TEST(RootDeviceEnvironment, givenEnableAILFlagSetToFalseWhenInitializingAILConfigurationThenSkipInitializingIt) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.EnableAIL.set(false);
+
+    MockExecutionEnvironment executionEnvironment;
+    auto rootDeviceEnvironment = static_cast<MockRootDeviceEnvironment *>(executionEnvironment.rootDeviceEnvironments[0].get());
+    ASSERT_EQ(nullptr, rootDeviceEnvironment->ailConfiguration);
+    rootDeviceEnvironment->initAilConfiguration();
+    EXPECT_EQ(nullptr, rootDeviceEnvironment->ailConfiguration);
+}
+
 TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenLocalMemorySupportedInMemoryManagerHasCorrectValue) {
     const HardwareInfo *hwInfo = defaultHwInfo.get();
     auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(hwInfo));
diff --git a/shared/test/unit_test/gen12lp/dg1/execution_environment_tests_dg1.cpp b/shared/test/unit_test/gen12lp/dg1/execution_environment_tests_dg1.cpp
index 1d59ccc2b7..34ecc074c4 100644
--- a/shared/test/unit_test/gen12lp/dg1/execution_environment_tests_dg1.cpp
+++ b/shared/test/unit_test/gen12lp/dg1/execution_environment_tests_dg1.cpp
@@ -1,12 +1,11 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
 #include "shared/source/ail/ail_configuration.h"
-#include "shared/test/common/helpers/variable_backup.h"
 #include "shared/test/common/mocks/mock_execution_environment.h"
 #include "shared/test/common/test_macros/hw_test.h"
 #include "shared/test/common/utilities/destructor_counted.h"
@@ -25,11 +24,7 @@ HWTEST2_F(RootDeviceEnvironmentTests, givenRootDeviceEnvironmentWhenAILInitProce
             return false;
         }
     };
-    VariableBackup<AILConfiguration *> ailConfiguration(&ailConfigurationTable[productFamily]);
-
-    AILDG1 ailDg1;
-    ailConfigurationTable[productFamily] = &ailDg1;
-
+    rootDeviceEnvironment->ailConfiguration.reset(new AILDG1());
     EXPECT_EQ(false, rootDeviceEnvironment->initAilConfiguration());
 }
 } // namespace NEO
diff --git a/shared/test/unit_test/xe_hpg_core/dg2/ail_tests_dg2.cpp b/shared/test/unit_test/xe_hpg_core/dg2/ail_tests_dg2.cpp
index 1fd7c5f66c..38885a8615 100644
--- a/shared/test/unit_test/xe_hpg_core/dg2/ail_tests_dg2.cpp
+++ b/shared/test/unit_test/xe_hpg_core/dg2/ail_tests_dg2.cpp
@@ -28,12 +28,7 @@ HWTEST2_F(AILTestsDg2, givenFixesForApplicationsWhenModifyKernelIfRequiredIsCall
         bool hashCorrect = {true};
     };
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
     AILMock ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(defaultHwInfo->platform.eProductFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
-
     std::string_view fixCode = "else { SYNC_WARPS; }";
 
     for (auto name : {"FAHBench-gui", "FAHBench-cmd"}) {
diff --git a/shared/test/unit_test/xe_hpg_core/mtl/ail_tests_mtl.cpp b/shared/test/unit_test/xe_hpg_core/mtl/ail_tests_mtl.cpp
index 92a8048edc..1ec27b5e78 100644
--- a/shared/test/unit_test/xe_hpg_core/mtl/ail_tests_mtl.cpp
+++ b/shared/test/unit_test/xe_hpg_core/mtl/ail_tests_mtl.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "shared/test/common/helpers/default_hw_info.h"
-#include "shared/test/common/helpers/variable_backup.h"
 #include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
@@ -15,9 +14,7 @@ namespace NEO {
 using AILTestsMTL = ::testing::Test;
 
 HWTEST2_F(AILTestsMTL, givenMtlWhenSvchostAppIsDetectedThenDisableDirectSubmission, IsMTL) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
+    AILWhitebox<productFamily> ail;
 
     auto capabilityTable = defaultHwInfo->capabilityTable;
     auto defaultEngineSupportedValue = capabilityTable.directSubmissionEngines.data[aub_stream::ENGINE_CCS].engineSupported;