diff --git a/tests/testDriver_capability_matrix_api.c b/tests/testDriver_capability_matrix_api.c
new file mode 100644
index 0000000..33ee7de
--- /dev/null
+++ b/tests/testDriver_capability_matrix_api.c
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+ * Copyright IBM Corp. 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "testsupport.h"
+
+#include <string.h>
+
+/*
+ * Tests for capability-matrix snapshot API.
+ */
+
+void setUp(void) {
+  memset(&nnpa_query_result, 0, sizeof(nnpa_query_result));
+  aiu_lib_vernum = 0;
+}
+
+void tearDown(void) {}
+
+void test_get_capability_matrix_rejects_null_output(void) {
+  TEST_ASSERT_EQUAL(ZDNN_INVALID_BUFFER, zdnn_get_capability_matrix(NULL));
+}
+
+void test_get_capability_matrix_returns_cached_query_snapshot(void) {
+  nnpa_query_result.installed_functions_vector.bits_0to63 = 0x0123456789ABCDEF;
+  nnpa_query_result.installed_functions_vector.bits_64to127 =
+      0x89ABCDEF01234567;
+  nnpa_query_result.installed_functions_vector.bits_128to191 =
+      0xAAAAAAAA55555555;
+  nnpa_query_result.installed_functions_vector.bits_192to255 =
+      0x13579BDF2468ACE0;
+
+  nnpa_query_result.installed_parameter_block_formats.bits_0to63 =
+      0x00FF00FF00FF00FF;
+  nnpa_query_result.installed_parameter_block_formats.bits_64to127 =
+      0x0F0F0F0F0F0F0F0F;
+
+  nnpa_query_result.installed_data_types = 0xA5A5;
+  nnpa_query_result.installed_dt1_conversions_vector = 0x5A5A;
+  nnpa_query_result.installed_data_layout_formats = 0xCC33CC33;
+  nnpa_query_result.maximum_dimension_index_size = 32768;
+  nnpa_query_result.max_dim4_index_size = 16384;
+  nnpa_query_result.max_dim3_index_size = 8192;
+  nnpa_query_result.max_dim2_index_size = 4096;
+  nnpa_query_result.max_dim1_index_size = 2048;
+  nnpa_query_result.maximum_tensor_size = 0x0000000180000000ULL;
+
+  aiu_lib_vernum = 0x01020A;
+
+  zdnn_capability_matrix caps;
+  memset(&caps, 0, sizeof(caps));
+
+  TEST_ASSERT_EQUAL(ZDNN_OK, zdnn_get_capability_matrix(&caps));
+
+  TEST_ASSERT_EQUAL_HEX64(0x0123456789ABCDEFULL, caps.installed_functions[0]);
+  TEST_ASSERT_EQUAL_HEX64(0x89ABCDEF01234567ULL, caps.installed_functions[1]);
+  TEST_ASSERT_EQUAL_HEX64(0xAAAAAAAA55555555ULL, caps.installed_functions[2]);
+  TEST_ASSERT_EQUAL_HEX64(0x13579BDF2468ACE0ULL, caps.installed_functions[3]);
+
+  TEST_ASSERT_EQUAL_HEX64(0x00FF00FF00FF00FFULL, caps.installed_parmblk_fmts[0]);
+  TEST_ASSERT_EQUAL_HEX64(0x0F0F0F0F0F0F0F0FULL, caps.installed_parmblk_fmts[1]);
+
+  TEST_ASSERT_EQUAL_HEX16(0xA5A5, caps.installed_data_types);
+  TEST_ASSERT_EQUAL_HEX16(0x5A5A, caps.installed_dt1_conversions);
+  TEST_ASSERT_EQUAL_HEX32(0xCC33CC33, caps.installed_data_layout_formats);
+
+  TEST_ASSERT_EQUAL_UINT32(32768, caps.maximum_dimension_index_size);
+  TEST_ASSERT_EQUAL_UINT32(16384, caps.max_dim4_index_size);
+  TEST_ASSERT_EQUAL_UINT32(8192, caps.max_dim3_index_size);
+  TEST_ASSERT_EQUAL_UINT32(4096, caps.max_dim2_index_size);
+  TEST_ASSERT_EQUAL_UINT32(2048, caps.max_dim1_index_size);
+  TEST_ASSERT_EQUAL_HEX64(0x0000000180000000ULL, caps.maximum_tensor_size);
+  TEST_ASSERT_EQUAL_HEX32(0x01020A, caps.aiu_library_version);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+
+  RUN_TEST(test_get_capability_matrix_rejects_null_output);
+  RUN_TEST(test_get_capability_matrix_returns_cached_query_snapshot);
+
+  return UNITY_END();
+}
diff --git a/tests/testDriver_query_count_safety.c b/tests/testDriver_query_count_safety.c
new file mode 100644
index 0000000..ddd6a61
--- /dev/null
+++ b/tests/testDriver_query_count_safety.c
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+ * Copyright IBM Corp. 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "testsupport.h"
+
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+
+/*
+ * Regression tests for query varargs count handling.
+ *
+ * Before this hardening, these loops used small unsigned counters (uint16_t
+ * and uint8_t) against an int `count`. Very large count values could cause
+ * counter wraparound and non-terminating loops.
+ */
+
+void setUp(void) {
+  memset(&nnpa_query_result, 0, sizeof(nnpa_query_result));
+
+  // Mark all functions/formats as installed so negative checks in this file are
+  // specifically validating count/input guards.
+  nnpa_query_result.installed_functions_vector.bits_0to63 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_64to127 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_128to191 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_192to255 = UINT64_MAX;
+  nnpa_query_result.installed_parameter_block_formats.bits_0to63 = UINT64_MAX;
+  nnpa_query_result.installed_parameter_block_formats.bits_64to127 =
+      UINT64_MAX;
+}
+
+void tearDown(void) {}
+
+void test_function_query_rejects_non_positive_count(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed(0));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed(-1));
+}
+
+void test_function_query_rejects_count_above_bitmap_capacity(void) {
+  int too_many =
+      (int)BIT_SIZEOF(nnpa_query_result.installed_functions_vector) + 1;
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed(too_many));
+}
+
+void test_function_query_rejects_extreme_count(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed(INT_MAX));
+}
+
+void test_function_query_rejects_negative_function_code(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed(1, -1));
+}
+
+void test_function_query_valid_input_still_succeeds(void) {
+  TEST_ASSERT_TRUE(zdnn_is_nnpa_function_installed(2, NNPA_ADD, NNPA_SOFTMAX));
+}
+
+void test_parmblk_query_rejects_non_positive_count(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed(0));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed(-1));
+}
+
+void test_parmblk_query_rejects_count_above_bitmap_capacity(void) {
+  int too_many =
+      (int)BIT_SIZEOF(nnpa_query_result.installed_parameter_block_formats) + 1;
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed(too_many));
+}
+
+void test_parmblk_query_rejects_extreme_count(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed(INT_MAX));
+}
+
+void test_parmblk_query_rejects_negative_format_code(void) {
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed(1, -1));
+}
+
+void test_parmblk_query_valid_input_still_succeeds(void) {
+  TEST_ASSERT_TRUE(
+      zdnn_is_nnpa_parmblk_fmt_installed(1, NNPA_PARMBLKFORMAT_0));
+}
+
+int main(void) {
+  UNITY_BEGIN();
+
+  RUN_TEST(test_function_query_rejects_non_positive_count);
+  RUN_TEST(test_function_query_rejects_count_above_bitmap_capacity);
+  RUN_TEST(test_function_query_rejects_extreme_count);
+  RUN_TEST(test_function_query_rejects_negative_function_code);
+  RUN_TEST(test_function_query_valid_input_still_succeeds);
+  RUN_TEST(test_parmblk_query_rejects_non_positive_count);
+  RUN_TEST(test_parmblk_query_rejects_count_above_bitmap_capacity);
+  RUN_TEST(test_parmblk_query_rejects_extreme_count);
+  RUN_TEST(test_parmblk_query_rejects_negative_format_code);
+  RUN_TEST(test_parmblk_query_valid_input_still_succeeds);
+
+  return UNITY_END();
+}
diff --git a/tests/testDriver_query_typed_wrappers.c b/tests/testDriver_query_typed_wrappers.c
new file mode 100644
index 0000000..50a07d5
--- /dev/null
+++ b/tests/testDriver_query_typed_wrappers.c
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+ * Copyright IBM Corp. 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "testsupport.h"
+
+#include <stdint.h>
+#include <string.h>
+
+void setUp(void) {
+  memset(&nnpa_query_result, 0, sizeof(nnpa_query_result));
+
+  // Start with all bits installed so each test can remove only what it needs.
+  nnpa_query_result.installed_functions_vector.bits_0to63 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_64to127 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_128to191 = UINT64_MAX;
+  nnpa_query_result.installed_functions_vector.bits_192to255 = UINT64_MAX;
+  nnpa_query_result.installed_parameter_block_formats.bits_0to63 = UINT64_MAX;
+  nnpa_query_result.installed_parameter_block_formats.bits_64to127 =
+      UINT64_MAX;
+}
+
+void tearDown(void) {}
+
+void test_function_list_rejects_null_or_zero_count(void) {
+  nnpa_function_code funcs[] = {NNPA_ADD};
+
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed_list(NULL, 1));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed_list(funcs, 0));
+}
+
+void test_function_list_rejects_invalid_entries(void) {
+  nnpa_function_code invalid_negative[] = {(nnpa_function_code)-1};
+  nnpa_function_code invalid_large[] = {(nnpa_function_code)999};
+
+  TEST_ASSERT_FALSE(
+      zdnn_is_nnpa_function_installed_list(invalid_negative, 1));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed_list(invalid_large, 1));
+}
+
+void test_function_list_matches_varargs_for_valid_input(void) {
+  nnpa_function_code funcs[] = {NNPA_ADD, NNPA_SOFTMAX, NNPA_TRANSFORM};
+
+  bool typed = zdnn_is_nnpa_function_installed_list(funcs, 3);
+  bool variadic = zdnn_is_nnpa_function_installed(3, NNPA_ADD, NNPA_SOFTMAX,
+                                                   NNPA_TRANSFORM);
+
+  TEST_ASSERT_TRUE(typed);
+  TEST_ASSERT_EQUAL(variadic, typed);
+}
+
+void test_function_list_reports_missing_function(void) {
+  nnpa_query_result.installed_functions_vector.bits_0to63 = 0;
+  nnpa_query_result.installed_functions_vector.bits_64to127 = 0;
+  nnpa_query_result.installed_functions_vector.bits_128to191 = 0;
+  nnpa_query_result.installed_functions_vector.bits_192to255 = 0;
+
+  nnpa_function_code funcs[] = {NNPA_ADD};
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_function_installed_list(funcs, 1));
+}
+
+void test_parmblk_list_rejects_null_or_zero_count(void) {
+  nnpa_parmblk_format formats[] = {NNPA_PARMBLKFORMAT_0};
+
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed_list(NULL, 1));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed_list(formats, 0));
+}
+
+void test_parmblk_list_rejects_invalid_entries(void) {
+  nnpa_parmblk_format invalid_negative[] = {(nnpa_parmblk_format)-1};
+  nnpa_parmblk_format invalid_large[] = {(nnpa_parmblk_format)999};
+
+  TEST_ASSERT_FALSE(
+      zdnn_is_nnpa_parmblk_fmt_installed_list(invalid_negative, 1));
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed_list(invalid_large, 1));
+}
+
+void test_parmblk_list_matches_varargs_for_valid_input(void) {
+  nnpa_parmblk_format formats[] = {NNPA_PARMBLKFORMAT_0, NNPA_PARMBLKFORMAT_1};
+
+  bool typed = zdnn_is_nnpa_parmblk_fmt_installed_list(formats, 2);
+  bool variadic =
+      zdnn_is_nnpa_parmblk_fmt_installed(2, NNPA_PARMBLKFORMAT_0,
+                                         NNPA_PARMBLKFORMAT_1);
+
+  TEST_ASSERT_TRUE(typed);
+  TEST_ASSERT_EQUAL(variadic, typed);
+}
+
+void test_parmblk_list_reports_missing_format(void) {
+  nnpa_query_result.installed_parameter_block_formats.bits_0to63 = 0;
+  nnpa_query_result.installed_parameter_block_formats.bits_64to127 = 0;
+
+  nnpa_parmblk_format formats[] = {NNPA_PARMBLKFORMAT_0};
+  TEST_ASSERT_FALSE(zdnn_is_nnpa_parmblk_fmt_installed_list(formats, 1));
+}
+
+int main(void) {
+  UNITY_BEGIN();
+
+  RUN_TEST(test_function_list_rejects_null_or_zero_count);
+  RUN_TEST(test_function_list_rejects_invalid_entries);
+  RUN_TEST(test_function_list_matches_varargs_for_valid_input);
+  RUN_TEST(test_function_list_reports_missing_function);
+  RUN_TEST(test_parmblk_list_rejects_null_or_zero_count);
+  RUN_TEST(test_parmblk_list_rejects_invalid_entries);
+  RUN_TEST(test_parmblk_list_matches_varargs_for_valid_input);
+  RUN_TEST(test_parmblk_list_reports_missing_format);
+
+  return UNITY_END();
+}
diff --git a/zdnn/query.c b/zdnn/query.c
index fa3b452..8c0dd2d 100644
--- a/zdnn/query.c
+++ b/zdnn/query.c
@@ -33,6 +33,8 @@
 #ifdef __MVS__
 #pragma export(zdnn_is_nnpa_function_installed)
 #pragma export(zdnn_is_nnpa_parmblk_fmt_installed)
+#pragma export(zdnn_is_nnpa_function_installed_list)
+#pragma export(zdnn_is_nnpa_parmblk_fmt_installed_list)
 #pragma export(zdnn_is_nnpa_datatype_installed)
 #pragma export(zdnn_is_nnpa_layout_fmt_installed)
 #pragma export(zdnn_get_nnpa_max_dim_idx_size)
@@ -40,6 +42,7 @@
 #pragma export(zdnn_get_nnpa_max_tensor_size)
 #pragma export(zdnn_refresh_nnpa_query_result)
 #pragma export(zdnn_is_nnpa_conversion_installed)
+#pragma export(zdnn_get_capability_matrix)
 #endif
 
 // Cached copy of the NNPA-QAF result.  zdnn_refresh_nnpa_query_result() is
@@ -56,17 +59,23 @@ nnpa_qaf_parameter_block nnpa_query_result;
 /// \return true if all queried functions are installed, false if any is not
 ///
 bool zdnn_is_nnpa_function_installed(int count, ...) {
+  int max_func = BIT_SIZEOF(nnpa_query_result.installed_functions_vector);
+  // Guard before va_start()/va_arg() so malformed callers cannot force
+  // out-of-bounds variadic reads.
+  if (count <= 0 || count > max_func) {
+    return false;
+  }
+
   va_list ap;
   va_start(ap, count);
   bool result = true;
 
-  uint16_t max_func = BIT_SIZEOF(nnpa_query_result.installed_functions_vector);
-
-  for (uint16_t i = 0; i < count; i++) {
-    uint16_t func_num = va_arg(ap, int);
-    if (func_num >= max_func || // protect ourselves from out-of-range input
+  for (int i = 0; i < count; i++) {
+    int func_num = va_arg(ap, int);
+    if (func_num < 0 ||
+        func_num >= max_func || // protect ourselves from out-of-range input
         !is_bitset_256(nnpa_query_result.installed_functions_vector,
-                       func_num)) {
+                       (uint16_t)func_num)) {
       result = false;
       break;
     }
@@ -84,18 +93,25 @@ bool zdnn_is_nnpa_function_installed(int count, ...) {
 /// \return true if all queried formats are installed, false if any is not
 ///
 bool zdnn_is_nnpa_parmblk_fmt_installed(int count, ...) {
+  int max_format =
+      BIT_SIZEOF(nnpa_query_result.installed_parameter_block_formats);
+  // Guard before va_start()/va_arg() so malformed callers cannot force
+  // out-of-bounds variadic reads.
+  if (count <= 0 || count > max_format) {
+    return false;
+  }
+
   va_list ap;
   va_start(ap, count);
   bool result = true;
 
-  uint8_t max_format =
-      BIT_SIZEOF(nnpa_query_result.installed_parameter_block_formats);
-
-  for (uint8_t i = 0; i < count; i++) {
-    uint8_t func_num = va_arg(ap, int);
-    if (func_num >= max_format || // protect ourselves from out-of-range input
+  for (int i = 0; i < count; i++) {
+    int format_num = va_arg(ap, int);
+    if (format_num < 0 ||
+        format_num >=
+            max_format || // protect ourselves from out-of-range input
         !is_bitset_128(nnpa_query_result.installed_parameter_block_formats,
-                       func_num)) {
+                       (uint8_t)format_num)) {
       result = false;
       break;
     }
@@ -104,6 +120,59 @@ bool zdnn_is_nnpa_parmblk_fmt_installed(int count, ...) {
   return result;
 }
 
+/// Typed query for NNPA function availability.
+///
+/// \param[in] functions Pointer to NNPA function codes to query.
+/// \param[in] count Number of function codes in `functions`.
+///
+/// \return true if all queried functions are installed, false otherwise.
+///
+bool zdnn_is_nnpa_function_installed_list(const nnpa_function_code *functions,
+                                          uint32_t count) {
+  int max_func = BIT_SIZEOF(nnpa_query_result.installed_functions_vector);
+  if (!functions || count == 0 || count > (uint32_t)max_func) {
+    return false;
+  }
+
+  for (uint32_t i = 0; i < count; i++) {
+    int func_num = (int)functions[i];
+    if (func_num < 0 || func_num >= max_func ||
+        !is_bitset_256(nnpa_query_result.installed_functions_vector,
+                       (uint16_t)func_num)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Typed query for NNPA parameter-block format availability.
+///
+/// \param[in] formats Pointer to NNPA parameter-block formats to query.
+/// \param[in] count Number of format entries in `formats`.
+///
+/// \return true if all queried formats are installed, false otherwise.
+///
+bool zdnn_is_nnpa_parmblk_fmt_installed_list(const nnpa_parmblk_format *formats,
+                                             uint32_t count) {
+  int max_format =
+      BIT_SIZEOF(nnpa_query_result.installed_parameter_block_formats);
+  if (!formats || count == 0 || count > (uint32_t)max_format) {
+    return false;
+  }
+
+  for (uint32_t i = 0; i < count; i++) {
+    int format_num = (int)formats[i];
+    if (format_num < 0 || format_num >= max_format ||
+        !is_bitset_128(nnpa_query_result.installed_parameter_block_formats,
+                       (uint8_t)format_num)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 /// Query if NNPA data types are installed
 ///
 /// \param[in] types_bitmask OR'd type numbers as defined in
@@ -204,6 +273,51 @@ uint64_t zdnn_get_nnpa_max_tensor_size() {
   return nnpa_query_result.maximum_tensor_size;
 }
 
+/// Retrieve a consolidated capability snapshot from cached NNPA-QAF data.
+///
+/// \param[out] capabilities Pointer to destination capability struct.
+///
+/// \return ZDNN_OK
+///         ZDNN_INVALID_BUFFER
+///
+zdnn_status zdnn_get_capability_matrix(zdnn_capability_matrix *capabilities) {
+  if (!capabilities) {
+    return ZDNN_STATUS_NO_MSG(ZDNN_INVALID_BUFFER);
+  }
+
+  // Fill every field explicitly from the cached query result so callers can
+  // do startup feature planning from one stable snapshot.
+  capabilities->installed_functions[0] =
+      nnpa_query_result.installed_functions_vector.bits_0to63;
+  capabilities->installed_functions[1] =
+      nnpa_query_result.installed_functions_vector.bits_64to127;
+  capabilities->installed_functions[2] =
+      nnpa_query_result.installed_functions_vector.bits_128to191;
+  capabilities->installed_functions[3] =
+      nnpa_query_result.installed_functions_vector.bits_192to255;
+
+  capabilities->installed_parmblk_fmts[0] =
+      nnpa_query_result.installed_parameter_block_formats.bits_0to63;
+  capabilities->installed_parmblk_fmts[1] =
+      nnpa_query_result.installed_parameter_block_formats.bits_64to127;
+
+  capabilities->installed_data_types = nnpa_query_result.installed_data_types;
+  capabilities->installed_dt1_conversions =
+      nnpa_query_result.installed_dt1_conversions_vector;
+  capabilities->installed_data_layout_formats =
+      nnpa_query_result.installed_data_layout_formats;
+  capabilities->maximum_dimension_index_size =
+      nnpa_query_result.maximum_dimension_index_size;
+  capabilities->max_dim4_index_size = nnpa_query_result.max_dim4_index_size;
+  capabilities->max_dim3_index_size = nnpa_query_result.max_dim3_index_size;
+  capabilities->max_dim2_index_size = nnpa_query_result.max_dim2_index_size;
+  capabilities->max_dim1_index_size = nnpa_query_result.max_dim1_index_size;
+  capabilities->maximum_tensor_size = nnpa_query_result.maximum_tensor_size;
+  capabilities->aiu_library_version = aiu_lib_vernum;
+
+  return ZDNN_STATUS_OK;
+}
+
 /// Refresh the nnpa_query_result struct from zAIU
 ///
 /// \param[in] result pointer to aiu_parameter_block_nnpa_qaf struct
diff --git a/zdnn/zdnn.h b/zdnn/zdnn.h
index 0c9cacc..52b3dcf 100644
--- a/zdnn/zdnn.h
+++ b/zdnn/zdnn.h
@@ -238,6 +238,32 @@ typedef enum zdnn_query_bfpfmts {
   QUERY_BFPFMT_SHORT = MSB_BITMASK(16, NNPA_BFPFMT_SHORT)
 } zdnn_query_bfpfmts;
 
+// Snapshot of zDNN capability information derived from cached NNPA-QAF data.
+//
+// Notes:
+// - This is a read-only view of zDNN's cached query state.
+// - Bit vectors preserve NNPA-QAF bit numbering in 64-bit chunks:
+//   - installed_functions[0]    => bits 0..63
+//   - installed_functions[1]    => bits 64..127
+//   - installed_functions[2]    => bits 128..191
+//   - installed_functions[3]    => bits 192..255
+//   - installed_parmblk_fmts[0] => bits 0..63
+//   - installed_parmblk_fmts[1] => bits 64..127
+typedef struct zdnn_capability_matrix {
+  uint64_t installed_functions[4];
+  uint64_t installed_parmblk_fmts[2];
+  uint16_t installed_data_types;
+  uint16_t installed_dt1_conversions;
+  uint32_t installed_data_layout_formats;
+  uint32_t maximum_dimension_index_size;
+  uint32_t max_dim4_index_size;
+  uint32_t max_dim3_index_size;
+  uint32_t max_dim2_index_size;
+  uint32_t max_dim1_index_size;
+  uint64_t maximum_tensor_size;
+  uint32_t aiu_library_version;
+} zdnn_capability_matrix;
+
 // -----------------------------------------------------------------------------
 // ZDNN enums
 // -----------------------------------------------------------------------------
@@ -460,6 +486,10 @@ zdnn_status zdnn_getrange_ztensor(const zdnn_ztensor *ztensor, float *min,
 bool zdnn_is_nnpa_installed();
 bool zdnn_is_nnpa_function_installed(int count, ...);
 bool zdnn_is_nnpa_parmblk_fmt_installed(int count, ...);
+bool zdnn_is_nnpa_function_installed_list(const nnpa_function_code *functions,
+                                          uint32_t count);
+bool zdnn_is_nnpa_parmblk_fmt_installed_list(
+    const nnpa_parmblk_format *formats, uint32_t count);
 bool zdnn_is_nnpa_datatype_installed(uint16_t types_bitmask);
 bool zdnn_is_nnpa_layout_fmt_installed(uint32_t layout_bitmask);
 bool zdnn_is_nnpa_conversion_installed(nnpa_data_type type,
@@ -468,6 +498,7 @@ bool zdnn_is_nnpa_conversion_installed(nnpa_data_type type,
 uint32_t zdnn_get_nnpa_max_dim_idx_size();
 uint32_t zdnn_get_max_for_dim(uint8_t dimension);
 uint64_t zdnn_get_nnpa_max_tensor_size();
+zdnn_status zdnn_get_capability_matrix(zdnn_capability_matrix *capabilities);
 
 zdnn_status zdnn_refresh_nnpa_query_result();
 
diff --git a/zdnn/zdnn.map b/zdnn/zdnn.map
index d80d3a1..eebd277 100644
--- a/zdnn/zdnn.map
+++ b/zdnn/zdnn.map
@@ -98,6 +98,8 @@ ZDNN_1.0 {
     zdnn_is_nnpa_installed;
     zdnn_is_nnpa_function_installed;
     zdnn_is_nnpa_parmblk_fmt_installed;
+    zdnn_is_nnpa_function_installed_list;
+    zdnn_is_nnpa_parmblk_fmt_installed_list;
     zdnn_is_nnpa_datatype_installed;
     zdnn_is_nnpa_layout_fmt_installed;
     zdnn_is_nnpa_conversion_installed;
@@ -106,6 +108,7 @@ ZDNN_1.0 {
     zdnn_get_nnpa_max_dim_idx_size;
     zdnn_get_max_for_dim;
     zdnn_get_nnpa_max_tensor_size;
+    zdnn_get_capability_matrix;
     zdnn_get_library_version_str;
     zdnn_get_library_version;
     zdnn_refresh_nnpa_query_result;