diff --git a/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp b/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
index f4f7a7031b..df1e6a4b86 100644
--- a/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
+++ b/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
@@ -946,11 +946,43 @@ DecodeError decodeZeInfoKernelPayloadArguments(KernelDescriptor &dst, Yaml::Yaml
         dst.payloadMappings.explicitArgs.resize(maxArgumentIndex + 1);
         dst.kernelAttributes.numArgsToPatch = maxArgumentIndex + 1;
 
+        bool bindlessBufferAccess = false;
+        bool bindlessImageAccess = false;
+        bool bindfulBufferAccess = false;
+        bool bindfulImageAccess = false;
+
         for (const auto &arg : payloadArguments) {
             auto decodeErr = populateKernelPayloadArgument(dst, arg, outErrReason, outWarning);
             if (DecodeError::Success != decodeErr) {
                 return decodeErr;
             }
+
+            if (arg.addrmode == Types::Kernel::PayloadArgument::MemoryAddressingModeBindless) {
+                if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTPointer>()) {
+                    bindlessBufferAccess = true;
+                } else if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTImage>()) {
+                    bindlessImageAccess = true;
+                }
+            } else if (arg.addrmode == Types::Kernel::PayloadArgument::MemoryAddressingModeStateful) {
+                if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTPointer>()) {
+                    bindfulBufferAccess = true;
+                } else if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTImage>()) {
+                    bindfulImageAccess = true;
+                }
+            }
+        }
+
+        if ((bindlessBufferAccess && bindfulBufferAccess) ||
+            (bindlessImageAccess && bindfulImageAccess)) {
+            outErrReason.append("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n");
+            return DecodeError::InvalidBinary;
+        }
+
+        if (bindlessBufferAccess) {
+            dst.kernelAttributes.bufferAddressingMode = KernelDescriptor::BindlessAndStateless;
+        }
+        if (bindlessImageAccess) {
+            dst.kernelAttributes.imageAddressingMode = KernelDescriptor::Bindless;
         }
         dst.kernelAttributes.crossThreadDataSize = static_cast<uint16_t>(alignUp(dst.kernelAttributes.crossThreadDataSize, 32));
     }
diff --git a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
index b8948eb8ca..936bfedcf9 100644
--- a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
+++ b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
@@ -1508,6 +1508,110 @@ kernels:
     EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
 }
 
+TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessBufferAddressingWhenDecodingZeInfoThenBufferAddressingModeIsBindlessAndStateless) {
+    ConstStringRef zeinfo = R"===(
+kernels:
+    - name : some_kernel
+      execution_env:
+        simd_size: 8
+      payload_arguments:
+        - arg_type:        arg_bypointer
+          offset:          0
+          size:            4
+          arg_index:       0
+          addrmode:        bindless
+          addrspace:       global
+          access_type:     readwrite
+...
+)===";
+    auto err = decodeZeInfoKernelEntry(zeinfo);
+    EXPECT_EQ(NEO::DecodeError::Success, err);
+
+    EXPECT_EQ(KernelDescriptor::BindlessAndStateless, kernelDescriptor->kernelAttributes.bufferAddressingMode);
+}
+
+TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessImageAddressingWhenDecodingZeInfoThenImageAddressingModeIsBindless) {
+    ConstStringRef zeinfo = R"===(
+kernels:
+    - name : some_kernel
+      execution_env:
+        simd_size: 8
+      payload_arguments:
+        - arg_type:        arg_bypointer
+          offset:          0
+          size:            0
+          arg_index:       0
+          addrmode:        bindless
+          addrspace:       image
+          access_type:     readonly
+          image_type:      image_2d
+...
+)===";
+    auto err = decodeZeInfoKernelEntry(zeinfo);
+    EXPECT_EQ(NEO::DecodeError::Success, err);
+
+    EXPECT_EQ(KernelDescriptor::Bindless, kernelDescriptor->kernelAttributes.imageAddressingMode);
+}
+
+TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessAndBindfulBufferAddressingWhenDecodingZeInfoThenErrorReturned) {
+    ConstStringRef zeinfo = R"===(
+kernels:
+    - name : some_kernel
+      execution_env:
+        simd_size: 8
+      payload_arguments:
+        - arg_type:        arg_bypointer
+          offset:          0
+          size:            4
+          arg_index:       0
+          addrmode:        bindless
+          addrspace:       global
+          access_type:     readwrite
+        - arg_type:        arg_bypointer
+          offset:          4
+          size:            4
+          arg_index:       1
+          addrmode:        stateful
+          addrspace:       global
+          access_type:     readwrite
+...
+)===";
+    auto err = decodeZeInfoKernelEntry(zeinfo);
+    EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
+    EXPECT_STREQ("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n", errors.c_str());
+    EXPECT_EQ(KernelDescriptor::BindfulAndStateless, kernelDescriptor->kernelAttributes.bufferAddressingMode);
+}
+
+TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessAndBindfulImageAddressingWhenDecodingZeInfoThenErrorReturned) {
+    ConstStringRef zeinfo = R"===(
+kernels:
+    - name : some_kernel
+      execution_env:
+        simd_size: 8
+      payload_arguments:
+        - arg_type:        arg_bypointer
+          offset:          0
+          size:            0
+          arg_index:       0
+          addrmode:        bindless
+          addrspace:       image
+          access_type:     readonly
+          image_type:      image_2d
+        - arg_type:        arg_bypointer
+          offset:          8
+          size:            0
+          arg_index:       1
+          addrmode:        stateful
+          addrspace:       image
+          access_type:     readonly
+          image_type:      image_2d
+...
+)===";
+    auto err = decodeZeInfoKernelEntry(zeinfo);
+    EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
+    EXPECT_STREQ("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n", errors.c_str());
+    EXPECT_EQ(KernelDescriptor::Bindful, kernelDescriptor->kernelAttributes.imageAddressingMode);
+}
 TEST(ReadZeInfoExecutionEnvironment, GivenValidYamlEntriesThenSetProperMembers) {
     NEO::ConstStringRef yaml = R"===(---
 kernels: