diff --git a/shared/source/device_binary_format/zebin/zeinfo.h b/shared/source/device_binary_format/zebin/zeinfo.h
index f8b49073de..f82ac4ea2d 100644
--- a/shared/source/device_binary_format/zebin/zeinfo.h
+++ b/shared/source/device_binary_format/zebin/zeinfo.h
@@ -66,6 +66,8 @@ inline constexpr ConstStringRef hasSample("has_sample");
 inline constexpr ConstStringRef actualKernelStartOffset("actual_kernel_start_offset");
 inline constexpr ConstStringRef requireImplicitArgBuffer("require_iab");
 inline constexpr ConstStringRef hasLscStoresWithNonDefaultL1CacheControls("has_lsc_stores_with_non_default_l1_cache_controls");
+inline constexpr ConstStringRef hasPrintfCalls("has_printf_calls");
+inline constexpr ConstStringRef hasIndirectCalls("has_indirect_calls");
 
 namespace ThreadSchedulingMode {
 inline constexpr ConstStringRef ageBased("age_based");
@@ -364,6 +366,8 @@ using WalkOrderT = int32_t;
 using PartitionDimT = int32_t;
 using RequireImplicitArgBufferT = bool;
 using HasLscStoresWithNonDefaultL1CacheControlsT = bool;
+using HasPrintfCallsT = bool;
+using HasIndirectCallsT = bool;
 
 namespace Defaults {
 inline constexpr BarrierCountT barrierCount = 0;
@@ -400,6 +404,8 @@ inline constexpr WalkOrderT dispatchWalkOrder = -1;
 inline constexpr PartitionDimT partitionDim = -1;
 inline constexpr RequireImplicitArgBufferT requireImplicitArgBuffer = false;
 inline constexpr HasLscStoresWithNonDefaultL1CacheControlsT hasLscStoresWithNonDefaultL1CacheControls = false;
+inline constexpr HasPrintfCallsT hasPrintfCalls = false;
+inline constexpr HasIndirectCallsT hasIndirectCalls = false;
 } // namespace Defaults
 
 inline constexpr ConstStringRef required[] = {
@@ -444,6 +450,8 @@ struct ExecutionEnvBaseT final : NEO::NonCopyableAndNonMovableClass {
     PartitionDimT partitionDim = Defaults::partitionDim;
     RequireImplicitArgBufferT requireImplicitArgBuffer = Defaults::requireImplicitArgBuffer;
     HasLscStoresWithNonDefaultL1CacheControlsT hasLscStoresWithNonDefaultL1CacheControls = Defaults::hasLscStoresWithNonDefaultL1CacheControls;
+    HasPrintfCallsT hasPrintfCalls = Defaults::hasPrintfCalls;
+    HasIndirectCallsT hasIndirectCalls = Defaults::hasIndirectCalls;
 };
 
 static_assert(NEO::NonCopyableAndNonMovable<ExecutionEnvBaseT>);
diff --git a/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp b/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
index db4ed1e1cb..5ea52d92fb 100644
--- a/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
+++ b/shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
@@ -691,6 +691,10 @@ DecodeError readZeInfoExecutionEnvironment(const Yaml::YamlParser &parser, const
             // ignore intentionally - deprecated and redundant key
         } else if (Tags::Kernel::ExecutionEnv::hasLscStoresWithNonDefaultL1CacheControls == key) {
             validExecEnv &= readZeInfoValueChecked(parser, execEnvMetadataNd, outExecEnv.hasLscStoresWithNonDefaultL1CacheControls, context, outErrReason);
+        } else if (Tags::Kernel::ExecutionEnv::hasPrintfCalls == key) {
+            validExecEnv &= readZeInfoValueChecked(parser, execEnvMetadataNd, outExecEnv.hasPrintfCalls, context, outErrReason);
+        } else if (Tags::Kernel::ExecutionEnv::hasIndirectCalls == key) {
+            validExecEnv &= readZeInfoValueChecked(parser, execEnvMetadataNd, outExecEnv.hasIndirectCalls, context, outErrReason);
         } else {
             readZeInfoValueCheckedExtra(parser, execEnvMetadataNd, outExecEnv, context, key, outErrReason, outWarning, validExecEnv, err);
         }
diff --git a/shared/source/device_binary_format/zebin/zeinfo_decoder.h b/shared/source/device_binary_format/zebin/zeinfo_decoder.h
index 9c6534fac2..4def0178fd 100644
--- a/shared/source/device_binary_format/zebin/zeinfo_decoder.h
+++ b/shared/source/device_binary_format/zebin/zeinfo_decoder.h
@@ -19,7 +19,7 @@ struct KernelInfo;
 struct ProgramInfo;
 
 namespace Zebin::ZeInfo {
-inline constexpr NEO::Zebin::ZeInfo::Types::Version zeInfoDecoderVersion{1, 58};
+inline constexpr NEO::Zebin::ZeInfo::Types::Version zeInfoDecoderVersion{1, 59};
 
 using KernelExecutionEnvBaseT = Types::Kernel::ExecutionEnv::ExecutionEnvBaseT;
 
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 62a2711833..546a983281 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
@@ -1958,6 +1958,8 @@ kernels:
         thread_scheduling_mode: age_based
         indirect_stateless_count: 2
         has_lsc_stores_with_non_default_l1_cache_controls: true
+        has_printf_calls: true
+        has_indirect_calls: true
 ...
 )===";
 
@@ -2006,6 +2008,68 @@ kernels:
     EXPECT_EQ(ThreadSchedulingMode::ThreadSchedulingModeAgeBased, execEnv.threadSchedulingMode);
     EXPECT_EQ(2, execEnv.indirectStatelessCount);
     EXPECT_TRUE(execEnv.hasLscStoresWithNonDefaultL1CacheControls);
+    EXPECT_TRUE(execEnv.hasPrintfCalls);
+    EXPECT_TRUE(execEnv.hasIndirectCalls);
+}
+
+TEST(ReadZeInfoExecutionEnvironment, GivenMinimalExecutionEnvThenSetProperMembersToDefaults) {
+    NEO::ConstStringRef yaml = R"===(---
+kernels:
+  - name:            some_kernel
+    execution_env:
+        simd_size: 32
+        grf_count: 128
+)===";
+
+    std::string parserErrors;
+    std::string parserWarnings;
+    NEO::Yaml::YamlParser parser;
+    bool success = parser.parse(yaml, parserErrors, parserWarnings);
+    ASSERT_TRUE(success);
+    auto &execEnvNode = *parser.findNodeWithKeyDfs("execution_env");
+    std::string errors;
+    std::string warnings;
+    NEO::Zebin::ZeInfo::Types::Kernel::ExecutionEnv::ExecutionEnvBaseT execEnv{};
+    EXPECT_FALSE(execEnv.hasSample);
+
+    auto err = NEO::Zebin::ZeInfo::readZeInfoExecutionEnvironment(parser, execEnvNode, execEnv, "some_kernel", errors, warnings);
+    EXPECT_EQ(NEO::DecodeError::success, err);
+    EXPECT_TRUE(errors.empty()) << errors;
+    EXPECT_TRUE(warnings.empty()) << warnings;
+
+    EXPECT_EQ(32, execEnv.simdSize);
+    EXPECT_EQ(128, execEnv.grfCount);
+
+    namespace Defaults = NEO::Zebin::ZeInfo::Types::Kernel::ExecutionEnv::Defaults;
+    EXPECT_EQ(Defaults::barrierCount, execEnv.barrierCount);
+    EXPECT_EQ(Defaults::disableMidThreadPreemption, execEnv.disableMidThreadPreemption);
+    EXPECT_EQ(Defaults::has4GBBuffers, execEnv.has4GBBuffers);
+    EXPECT_EQ(Defaults::hasDpas, execEnv.hasDpas);
+    EXPECT_EQ(Defaults::hasFenceForImageAccess, execEnv.hasFenceForImageAccess);
+    EXPECT_EQ(Defaults::hasGlobalAtomics, execEnv.hasGlobalAtomics);
+    EXPECT_EQ(Defaults::hasMultiScratchSpaces, execEnv.hasMultiScratchSpaces);
+    EXPECT_EQ(Defaults::hasNoStatelessWrite, execEnv.hasNoStatelessWrite);
+    EXPECT_EQ(Defaults::hasStackCalls, execEnv.hasStackCalls);
+    EXPECT_EQ(Defaults::hasRTCalls, execEnv.hasRTCalls);
+    EXPECT_EQ(Defaults::hasSample, execEnv.hasSample);
+    EXPECT_EQ(Defaults::hwPreemptionMode, execEnv.hwPreemptionMode);
+    EXPECT_EQ(Defaults::inlineDataPayloadSize, execEnv.inlineDataPayloadSize);
+    EXPECT_EQ(Defaults::offsetToSkipPerThreadDataLoad, execEnv.offsetToSkipPerThreadDataLoad);
+    EXPECT_EQ(Defaults::offsetToSkipSetFfidGp, execEnv.offsetToSkipSetFfidGp);
+    EXPECT_EQ(Defaults::requiredSubGroupSize, execEnv.requiredSubGroupSize);
+    EXPECT_EQ(Defaults::slmSize, execEnv.slmSize);
+    EXPECT_EQ(Defaults::subgroupIndependentForwardProgress, execEnv.subgroupIndependentForwardProgress);
+    EXPECT_EQ(Defaults::requiredWorkGroupSize[0], execEnv.requiredWorkGroupSize[0]);
+    EXPECT_EQ(Defaults::requiredWorkGroupSize[1], execEnv.requiredWorkGroupSize[1]);
+    EXPECT_EQ(Defaults::requiredWorkGroupSize[2], execEnv.requiredWorkGroupSize[2]);
+    EXPECT_EQ(Defaults::workgroupWalkOrderDimensions[0], execEnv.workgroupWalkOrderDimensions[0]);
+    EXPECT_EQ(Defaults::workgroupWalkOrderDimensions[1], execEnv.workgroupWalkOrderDimensions[1]);
+    EXPECT_EQ(Defaults::workgroupWalkOrderDimensions[2], execEnv.workgroupWalkOrderDimensions[2]);
+    EXPECT_EQ(Defaults::threadSchedulingMode, execEnv.threadSchedulingMode);
+    EXPECT_EQ(Defaults::indirectStatelessCount, execEnv.indirectStatelessCount);
+    EXPECT_EQ(Defaults::hasLscStoresWithNonDefaultL1CacheControls, execEnv.hasLscStoresWithNonDefaultL1CacheControls);
+    EXPECT_EQ(Defaults::hasPrintfCalls, execEnv.hasPrintfCalls);
+    EXPECT_EQ(Defaults::hasIndirectCalls, execEnv.hasIndirectCalls);
 }
 
 TEST(ReadZeInfoExecutionEnvironment, GivenUnknownEntryThenEmitsError) {