diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index b133d79bca96c..6aaf5f488b681 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -140,8 +140,6 @@ pub enum Handle<A: Asset> {
     Uuid(Uuid, #[reflect(ignore, clone)] PhantomData<fn() -> A>),
 }
 
-// `Handle` needs a custom `FromReflect` to do extra type checking - see the
-// `strong_handle.type_id` check below.
 // `Handle` needs a custom `FromReflect` to do extra type checking - see the
 // `strong_handle.type_id` check below.
 impl<A: Asset> FromReflect for Handle<A>
@@ -737,11 +735,11 @@ pub enum UntypedAssetConversionError {
 mod tests {
     use alloc::boxed::Box;
     use bevy_platform::hash::FixedHasher;
-    use bevy_reflect::PartialReflect;
+    use bevy_reflect::{FromReflect, PartialReflect};
     use core::hash::BuildHasher;
     use uuid::Uuid;
 
-    use crate::tests::create_app;
+    use crate::{tests::create_app, AssetApp, Assets, VisitAssetDependencies};
 
     use super::*;
 
@@ -847,9 +845,6 @@ mod tests {
     /// `PartialReflect::reflect_clone`/`PartialReflect::to_dynamic` should increase the strong count of a strong handle
     #[test]
     fn strong_handle_reflect_clone() {
-        use crate::{AssetApp, Assets, VisitAssetDependencies};
-        use bevy_reflect::FromReflect;
-
         #[derive(Reflect)]
         struct MyAsset {
             value: u32,
@@ -904,9 +899,6 @@ mod tests {
 
     #[test]
     fn handle_from_reflect_verifies_type_id() {
-        use crate::{AssetApp, Assets};
-        use bevy_reflect::FromReflect;
-
         #[derive(Reflect, Asset)]
         struct A;
         #[derive(Reflect, Asset)]
@@ -940,4 +932,50 @@ mod tests {
             "Handle<A> should be constructible from reflected Handle<A>"
         );
     }
+
+    #[test]
+    #[ignore = "Known failure tracked in #24111"]
+    fn handle_try_apply_verifies_type_id() {
+        #[derive(Reflect, Asset)]
+        struct A;
+        #[derive(Reflect, Asset)]
+        struct B;
+
+        let mut app = create_app().0;
+        app.init_asset::<A>().init_asset::<B>();
+
+        let mut assets_a = app.world_mut().resource_mut::<Assets<A>>();
+        let handle_a = assets_a.add(A);
+
+        let reflected_handle_a = handle_a.as_partial_reflect();
+
+        let mut assets_b = app.world_mut().resource_mut::<Assets<B>>();
+        let mut handle_b = assets_b.add(B);
+        assert!(
+            handle_b.try_apply(reflected_handle_a).is_err(),
+            "Handle<A> should not be applicable to Handle<B>"
+        );
+    }
+
+    #[test]
+    fn handle_from_reflect_and_try_apply() {
+        #[derive(Reflect, Asset)]
+        struct A(i32);
+
+        let mut app = create_app().0;
+        app.init_asset::<A>();
+
+        let mut assets = app.world_mut().resource_mut::<Assets<A>>();
+        let handle_1 = assets.add(A(1));
+        let reflected_handle_1 = handle_1.as_partial_reflect();
+
+        let handle_1_from_reflect: Handle<A> =
+            FromReflect::from_reflect(reflected_handle_1).unwrap();
+        assert_eq!(handle_1, handle_1_from_reflect);
+
+        let mut handle_2 = assets.add(A(2));
+        assert_ne!(handle_1, handle_2);
+        handle_2.try_apply(reflected_handle_1).unwrap();
+        assert_eq!(handle_1, handle_2);
+    }
 }