diff --git a/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_arg.hpp b/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_arg.hpp
index 10c3a5c36ba39..fcc1e6e8d8cad 100644
--- a/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_arg.hpp
+++ b/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_arg.hpp
@@ -76,6 +76,9 @@ __SYCL_TYPE(annotated_arg) annotated_arg<T *, detail::properties_t<Props...>> {
 public:
   static_assert(is_property_list<property_list_t>::value,
                 "Property list is invalid.");
+  static_assert(
+      validate_annotated_type<annotated_arg<T *, property_list_t>>::value,
+      "The property list contains invalid property.");
 
   annotated_arg() noexcept = default;
   annotated_arg(const annotated_arg &) = default;
@@ -178,8 +181,9 @@ __SYCL_TYPE(annotated_arg) annotated_arg<T, detail::properties_t<Props...>> {
   static_assert(is_device_copyable_v<T>, "Type T must be device copyable.");
   static_assert(is_property_list<property_list_t>::value,
                 "Property list is invalid.");
-  static_assert(check_property_list<T, Props...>::value,
-                "The property list contains invalid property.");
+  static_assert(
+      validate_annotated_type<annotated_arg<T, property_list_t>>::value,
+      "The property list contains invalid property.");
 
   annotated_arg() noexcept = default;
   annotated_arg(const annotated_arg &) = default;
diff --git a/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_ptr.hpp b/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_ptr.hpp
index 1998d18e11b8a..70fec047c0ac2 100644
--- a/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_ptr.hpp
+++ b/sycl/include/sycl/ext/oneapi/annotated_arg/annotated_ptr.hpp
@@ -121,6 +121,9 @@ __SYCL_TYPE(annotated_ptr) annotated_ptr<T, detail::properties_t<Props...>> {
 public:
   static_assert(is_property_list<property_list_t>::value,
                 "Property list is invalid.");
+  static_assert(
+      validate_annotated_type<annotated_ptr<T, property_list_t>>::value,
+      "The property list contains invalid property.");
 
   annotated_ptr() noexcept = default;
   annotated_ptr(const annotated_ptr &) = default;
diff --git a/sycl/include/sycl/ext/oneapi/annotated_arg/properties.hpp b/sycl/include/sycl/ext/oneapi/annotated_arg/properties.hpp
index 277859a4f71c0..482e201a95655 100644
--- a/sycl/include/sycl/ext/oneapi/annotated_arg/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/annotated_arg/properties.hpp
@@ -327,15 +327,60 @@ struct is_valid_property<T, conduit_key::value_t> : std::true_type {};
 template <typename T>
 struct is_valid_property<T, stable_key::value_t> : std::true_type {};
 
+// Check if a given property is supported for annotated_arg
+// e.g. `alignment` is not supported for annotated_arg
+template <typename PropT>
+using is_property_value_of_annotated_arg =
+    is_property_value_of<PropT,
+                         annotated_arg<void, detail::empty_properties_t>>;
+
+// Check if a given property is supported for annotated_ptr
+template <typename PropT>
+using is_property_value_of_annotated_ptr =
+    is_property_value_of<PropT,
+                         annotated_ptr<void, detail::empty_properties_t>>;
+
+// Validate anntoated_arg/annotated_ptr
+template <typename T> struct validate_annotated_type : std::false_type {};
+
+// Partial specializations for validating annotated_arg
 template <typename T, typename... Props>
-struct check_property_list : std::true_type {};
+struct validate_annotated_type<annotated_arg<T, detail::properties_t<Props...>>>
+    : std::true_type {};
 
 template <typename T, typename Prop, typename... Props>
-struct check_property_list<T, Prop, Props...>
-    : std::conditional_t<is_valid_property<T, Prop>::value,
-                         check_property_list<T, Props...>, std::false_type> {
-  static_assert(is_valid_property<T, Prop>::value,
-                "Property is invalid for the given type.");
+struct validate_annotated_type<
+    annotated_arg<T, detail::properties_t<Prop, Props...>>>
+    : std::conditional_t<is_valid_property<T, Prop>::value &&
+                             is_property_value_of_annotated_arg<Prop>::value,
+                         validate_annotated_type<
+                             annotated_arg<T, detail::properties_t<Props...>>>,
+                         std::false_type> {
+  static_assert(
+      is_valid_property<T, Prop>::value,
+      "Property is invalid for the underlying type of annotated_arg.");
+  static_assert(is_property_value_of_annotated_arg<Prop>::value,
+                "Property is not supported for annotated_arg.");
+};
+
+// Partial specializations for validating annotated_arg
+template <typename T, typename... Props>
+struct validate_annotated_type<annotated_ptr<T, detail::properties_t<Props...>>>
+    : std::true_type {};
+
+template <typename T, typename Prop, typename... Props>
+struct validate_annotated_type<
+    annotated_ptr<T, detail::properties_t<Prop, Props...>>>
+    : std::conditional_t<is_valid_property<T *, Prop>::value &&
+                             is_property_value_of_annotated_ptr<Prop>::value,
+                         validate_annotated_type<
+                             annotated_ptr<T, detail::properties_t<Props...>>>,
+                         std::false_type> {
+  static_assert(
+      is_valid_property<T *, Prop>::value,
+      "Property is invalid for the underlying type of annotated_ptr.");
+  static_assert(is_property_value_of_annotated_ptr<Prop>::value,
+                "Property is not supported for annotated_ptr.");
 };
 
 //===----------------------------------------------------------------------===//
@@ -354,6 +399,10 @@ template <typename T, typename PropertyListT>
 struct is_property_key_of<alignment_key, annotated_ptr<T, PropertyListT>>
     : std::true_type {};
 
+template <typename T, int K>
+struct is_valid_property<T, alignment_key::value_t<K>>
+    : std::bool_constant<std::is_pointer<T>::value> {};
+
 namespace detail {
 
 template <> struct PropertyToKind<alignment_key> {