diff --git a/Cargo.toml b/Cargo.toml
index 0fafd91be7970..4c7c1fbc7dc42 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -258,6 +258,10 @@ name = "custom_diagnostic"
 path = "examples/diagnostics/custom_diagnostic.rs"
 
 # ECS (Entity Component System)
+[[example]]
+name = "ambiguity_checker"
+path = "examples/ecs/ambiguity_checker.rs"
+
 [[example]]
 name = "ecs_guide"
 path = "examples/ecs/ecs_guide.rs"
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 5f44d68f9f40b..2ddbecafaea59 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -13,7 +13,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::{schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem};
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
@@ -31,5 +31,10 @@ impl Plugin for AudioPlugin {
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
         app.init_asset_loader::<Mp3Loader>();
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_audio".to_string());
     }
 }
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 9d5dda4bdf385..ad9c46b4d86e5 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -11,12 +11,15 @@ use crate::{
     },
     world::{World, WorldId},
 };
-use bevy_utils::{tracing::info, HashMap, HashSet};
+use bevy_utils::{
+    tracing::{info, warn},
+    HashMap, HashSet,
+};
 use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
 
-use super::IntoSystemDescriptor;
+use super::{AmbiguityDetection, IntoSystemDescriptor};
 
 pub trait Stage: Downcast + Send + Sync {
     /// Runs the stage; this happens once per update.
@@ -26,10 +29,13 @@ pub trait Stage: Downcast + Send + Sync {
 
 impl_downcast!(Stage);
 
-/// When this resource is present in the `App`'s `Resources`,
-/// each `SystemStage` will log a report containing
-/// pairs of systems with ambiguous execution order.
-///
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AmbiguityReportLevel {
+    Off,
+    Minimal,
+    Verbose,
+}
+
 /// Systems that access the same Component or Resource within the same stage
 /// risk an ambiguous order that could result in logic bugs, unless they have an
 /// explicit execution ordering constraint between them.
@@ -45,7 +51,78 @@ impl_downcast!(Stage);
 ///
 /// The checker may report a system more times than the amount of constraints it would actually need
 /// to have unambiguous order with regards to a group of already-constrained systems.
-pub struct ReportExecutionOrderAmbiguities;
+///
+/// By default only a warning with the number of unresolved ambiguities detected will be reported per [`SystemStage`].
+/// This behavior can be changed by explicitly adding this resource using the following constructors:
+/// * [ReportExecutionOrderAmbiguities::off()] - Disables all messages reported by the ambiguity checker.
+/// * [ReportExecutionOrderAmbiguities::minimal()] - Displays only the number of unresolved ambiguities detected by the ambiguity checker.
+/// * [ReportExecutionOrderAmbiguities::verbose()] - Displays a full report of ambiguities detected by the ambiguity checker.
+///
+/// The ambiguity checker will ignore ambiguities within official Bevy crates.
+/// To ignore a custom crate, use [`ReportExecutionOrderAmbiguities::ignore`]
+/// with an list of crate names as an argument.
+/// This resource should be added before any bevy internal plugin.
+///
+/// ## Example
+/// ```ignore
+/// # use bevy_app::App;
+/// # use bevy_ecs::schedule::ReportExecutionOrderAmbiguities;
+/// App::new()
+///    .insert_resource(ReportExecutionOrderAmbiguities::verbose().ignore(&["my_external_crate"]));
+/// ```
+pub struct ReportExecutionOrderAmbiguities {
+    pub level: AmbiguityReportLevel,
+    pub ignore_crates: Vec<String>,
+}
+
+impl ReportExecutionOrderAmbiguities {
+    /// Disables all messages reported by the ambiguity checker.
+    pub fn off() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Off,
+            ..Default::default()
+        }
+    }
+
+    /// Displays only the number of unresolved ambiguities detected by the ambiguity checker. This is the default behavior.
+    pub fn minimal() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ..Default::default()
+        }
+    }
+
+    /// Displays a full report of ambiguities detected by the ambiguity checker.
+    pub fn verbose() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Verbose,
+            ..Default::default()
+        }
+    }
+
+    /// Adds the given crate to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore(mut self, crate_prefix: &str) -> Self {
+        self.ignore_crates.push(crate_prefix.to_string());
+        self
+    }
+
+    /// Adds all the given crates to be ignored by ambiguity checker. Check [`ReportExecutionOrderAmbiguities`] for more details.
+    pub fn ignore_all(mut self, crate_prefixes: &[&str]) -> Self {
+        for s in crate_prefixes {
+            self.ignore_crates.push(s.to_string());
+        }
+        self
+    }
+}
+
+impl Default for ReportExecutionOrderAmbiguities {
+    fn default() -> Self {
+        Self {
+            level: AmbiguityReportLevel::Minimal,
+            ignore_crates: vec![],
+        }
+    }
+}
 
 /// Stores and executes systems. Execution order is not defined unless explicitly specified;
 /// see `SystemDescriptor` documentation.
@@ -470,7 +547,14 @@ impl SystemStage {
     }
 
     /// Logs execution order ambiguities between systems. System orders must be fresh.
-    fn report_ambiguities(&self, world: &World) {
+    fn report_ambiguities(&self, world: &mut World) {
+        let ambiguity_report =
+            world.get_resource_or_insert_with(ReportExecutionOrderAmbiguities::default);
+
+        if ambiguity_report.level == AmbiguityReportLevel::Off {
+            return;
+        }
+
         debug_assert!(!self.systems_modified);
         use std::fmt::Write;
         fn write_display_names_of_pairs(
@@ -478,61 +562,111 @@ impl SystemStage {
             systems: &[impl SystemContainer],
             mut ambiguities: Vec<(usize, usize, Vec<ComponentId>)>,
             world: &World,
+            output_prefix: &str,
         ) {
-            for (index_a, index_b, conflicts) in ambiguities.drain(..) {
+            use std::collections::hash_map;
+
+            let mut ambiguities_map: hash_map::HashMap<Vec<ComponentId>, Vec<usize>> =
+                hash_map::HashMap::new();
+
+            for (index_a, index_b, components) in ambiguities.drain(..) {
+                let systems = ambiguities_map.entry(components).or_default();
+                if !systems.contains(&index_a) {
+                    systems.push(index_a);
+                }
+                if !systems.contains(&index_b) {
+                    systems.push(index_b);
+                }
+            }
+
+            for (idx, (conflicts, systems_indices)) in ambiguities_map.drain().enumerate() {
+                let system_names = systems_indices
+                    .iter()
+                    .map(|index| systems[*index].name())
+                    .collect::<Vec<_>>();
+
+                let system_components = conflicts
+                    .iter()
+                    .map(|id| world.components().get_info(*id).unwrap().name())
+                    .collect::<Vec<_>>();
+
                 writeln!(
                     string,
-                    " -- {:?} and {:?}",
-                    systems[index_a].name(),
-                    systems[index_b].name()
+                    "{}.{} - Systems:\n     {:?}\n   - Conflict on the following components/resources:\n     {:?}",
+                    output_prefix, idx, system_names, system_components
                 )
                 .unwrap();
-                if !conflicts.is_empty() {
-                    let names = conflicts
-                        .iter()
-                        .map(|id| world.components().get_info(*id).unwrap().name())
-                        .collect::<Vec<_>>();
-                    writeln!(string, "    conflicts: {:?}", names).unwrap();
-                }
             }
         }
-        let parallel = find_ambiguities(&self.parallel);
-        let at_start = find_ambiguities(&self.exclusive_at_start);
-        let before_commands = find_ambiguities(&self.exclusive_before_commands);
-        let at_end = find_ambiguities(&self.exclusive_at_end);
+
+        let parallel = find_ambiguities(&self.parallel, &ambiguity_report.ignore_crates);
+        let at_start = find_ambiguities(&self.exclusive_at_start, &ambiguity_report.ignore_crates);
+        let before_commands = find_ambiguities(
+            &self.exclusive_before_commands,
+            &ambiguity_report.ignore_crates,
+        );
+        let at_end = find_ambiguities(&self.exclusive_at_end, &ambiguity_report.ignore_crates);
+
+        let mut unresolved_count = parallel.len();
+        unresolved_count += at_start.len();
+        unresolved_count += before_commands.len();
+        unresolved_count += at_end.len();
+
+        if unresolved_count > 0 {
+            let mut details = String::from("");
+
+            if ambiguity_report.level != AmbiguityReportLevel::Verbose {
+                write!(details, " Set the level of the ReportExecutionOrderAmbiguities resource to AmbiguityReportLevel::Verbose for more details.").unwrap();
+            }
+
+            warn!(
+                "{} unresolved ambiguities detected.{}",
+                unresolved_count, &details
+            );
+        }
+
         if !(parallel.is_empty()
             && at_start.is_empty()
             && before_commands.is_empty()
             && at_end.is_empty())
+            && ambiguity_report.level == AmbiguityReportLevel::Verbose
         {
             let mut string = "Execution order ambiguities detected, you might want to \
                     add an explicit dependency relation between some of these systems:\n"
                 .to_owned();
             if !parallel.is_empty() {
-                writeln!(string, " * Parallel systems:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.parallel, parallel, world);
+                writeln!(string, "1. Parallel systems:").unwrap();
+                write_display_names_of_pairs(&mut string, &self.parallel, parallel, world, "1");
             }
             if !at_start.is_empty() {
-                writeln!(string, " * Exclusive systems at start of stage:").unwrap();
+                writeln!(string, "2. Exclusive systems at start of stage:").unwrap();
                 write_display_names_of_pairs(
                     &mut string,
                     &self.exclusive_at_start,
                     at_start,
                     world,
+                    "2",
                 );
             }
             if !before_commands.is_empty() {
-                writeln!(string, " * Exclusive systems before commands of stage:").unwrap();
+                writeln!(string, "3. Exclusive systems before commands of stage:").unwrap();
                 write_display_names_of_pairs(
                     &mut string,
                     &self.exclusive_before_commands,
                     before_commands,
                     world,
+                    "3",
                 );
             }
             if !at_end.is_empty() {
-                writeln!(string, " * Exclusive systems at end of stage:").unwrap();
-                write_display_names_of_pairs(&mut string, &self.exclusive_at_end, at_end, world);
+                writeln!(string, "4. Exclusive systems at end of stage:").unwrap();
+                write_display_names_of_pairs(
+                    &mut string,
+                    &self.exclusive_at_end,
+                    at_end,
+                    world,
+                    "4",
+                );
             }
             info!("{}", string);
         }
@@ -664,7 +798,35 @@ fn process_systems(
 /// Returns vector containing all pairs of indices of systems with ambiguous execution order,
 /// along with specific components that have triggered the warning.
 /// Systems must be topologically sorted beforehand.
-fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<ComponentId>)> {
+fn find_ambiguities(
+    systems: &[impl SystemContainer],
+    crates_filter: &[String],
+) -> Vec<(usize, usize, Vec<ComponentId>)> {
+    fn should_ignore_ambiguity(
+        systems: &[impl SystemContainer],
+        index_a: usize,
+        index_b: usize,
+        crates_filter: &[String],
+    ) -> bool {
+        let system_a = &systems[index_a];
+        let system_b = &systems[index_b];
+
+        (match system_a.ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| system_b.labels().contains(l))
+            }
+        }) || (match system_b.ambiguity_detection() {
+            AmbiguityDetection::Ignore => true,
+            AmbiguityDetection::Check => false,
+            AmbiguityDetection::IgnoreWithLabel(labels) => {
+                labels.iter().any(|l| system_a.labels().contains(l))
+            }
+        }) || (crates_filter.iter().any(|s| system_a.name().starts_with(s))
+            && crates_filter.iter().any(|s| system_b.name().starts_with(s)))
+    }
+
     let mut ambiguity_set_labels = HashMap::default();
     for set in systems.iter().flat_map(|c| c.ambiguity_sets()) {
         let len = ambiguity_set_labels.len();
@@ -719,6 +881,7 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec<
         {
             if !processed.contains(index_b)
                 && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b])
+                && !should_ignore_ambiguity(systems, index_a, index_b, crates_filter)
             {
                 let a_access = systems[index_a].component_access();
                 let b_access = systems[index_b].component_access();
@@ -754,9 +917,7 @@ impl Stage for SystemStage {
             self.systems_modified = false;
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
-            if world.contains_resource::<ReportExecutionOrderAmbiguities>() {
-                self.report_ambiguities(world);
-            }
+            self.report_ambiguities(world);
         } else if self.executor_modified {
             self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
@@ -1559,7 +1720,24 @@ mod tests {
         fn find_ambiguities_first_labels(
             systems: &[impl SystemContainer],
         ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
-            find_ambiguities(systems)
+            find_ambiguities(systems, &[])
+                .drain(..)
+                .map(|(index_a, index_b, _conflicts)| {
+                    (
+                        systems[index_a].labels()[0].clone(),
+                        systems[index_b].labels()[0].clone(),
+                    )
+                })
+                .collect()
+        }
+
+        fn find_ambiguities_first_labels_with_filter(
+            systems: &[impl SystemContainer],
+            filter: &[String],
+        ) -> Vec<(BoxedSystemLabel, BoxedSystemLabel)> {
+            let mut find_ambiguities = find_ambiguities(systems, filter);
+
+            find_ambiguities
                 .drain(..)
                 .map(|(index_a, index_b, _conflicts)| {
                     (
@@ -1574,6 +1752,10 @@ mod tests {
         fn resource(_: ResMut<usize>) {}
         fn component(_: Query<&mut f32>) {}
 
+        mod inner {
+            pub(super) fn inner_fn(_: super::ResMut<usize>) {}
+        }
+
         let mut world = World::new();
 
         let mut stage = SystemStage::parallel()
@@ -1584,7 +1766,7 @@ mod tests {
             .with_system(empty.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.label("0"))
@@ -1624,7 +1806,7 @@ mod tests {
             .with_system(component.label("4"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
+        assert_eq!(find_ambiguities(&stage.parallel, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(component.label("0"))
@@ -1850,7 +2032,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("7").after("6"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
-        assert_eq!(find_ambiguities(&stage.exclusive_at_start).len(), 0);
+        assert_eq!(find_ambiguities(&stage.exclusive_at_start, &[]).len(), 0);
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("0").before("1").before("3"))
@@ -1927,6 +2109,96 @@ mod tests {
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
         assert_eq!(ambiguities.len(), 0);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0"))
+            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
+            .with_system(empty.label("2"))
+            .with_system(component.label("3").after("2").before("4"))
+            .with_system(resource.label("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert!(
+            ambiguities.contains(&(Box::new("0"), Box::new("3")))
+                || ambiguities.contains(&(Box::new("3"), Box::new("0")))
+        );
+        assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0").silence_ambiguity_checks())
+            .with_system(resource.label("1").after("0").silence_ambiguity_checks())
+            .with_system(empty.label("2"))
+            .with_system(component.label("3").after("2").before("4"))
+            .with_system(resource.label("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert_eq!(ambiguities.len(), 0);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("1")
+                    .silence_ambiguity_checks(),
+            )
+            .with_system(empty.exclusive_system().label("2").after("1"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("3")
+                    .silence_ambiguity_checks(),
+            )
+            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
+            .with_system(
+                empty
+                    .exclusive_system()
+                    .label("5")
+                    .silence_ambiguity_checks(),
+            )
+            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
+        assert!(
+            ambiguities.contains(&(Box::new("2"), Box::new("4")))
+                || ambiguities.contains(&(Box::new("4"), Box::new("2")))
+        );
+        assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(component.label("0"))
+            .with_system(resource.label("1").after("0"))
+            .with_system(empty.label("2"))
+            .with_system(
+                component
+                    .label("3")
+                    .after("2")
+                    .before("4")
+                    .ambiguous_with("0"),
+            )
+            .with_system(resource.label("4").ambiguous_with("4"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels(&stage.parallel);
+        assert!(
+            ambiguities.contains(&(Box::new("1"), Box::new("4")))
+                || ambiguities.contains(&(Box::new("4"), Box::new("1")))
+        );
+        assert_eq!(ambiguities.len(), 1);
+
+        let mut stage = SystemStage::parallel()
+            .with_system(resource.label("1"))
+            .with_system(inner::inner_fn.label("2"));
+        stage.initialize_systems(&mut world);
+        stage.rebuild_orders_and_dependencies();
+        let ambiguities = find_ambiguities_first_labels_with_filter(
+            &stage.parallel,
+            &["bevy_ecs::schedule::stage::tests::ambiguity_detection::inner::".into()],
+        );
+        assert_eq!(ambiguities.len(), 1);
     }
 
     #[test]
diff --git a/crates/bevy_ecs/src/schedule/system_container.rs b/crates/bevy_ecs/src/schedule/system_container.rs
index 68e493da714b5..6ca8c7cf4296e 100644
--- a/crates/bevy_ecs/src/schedule/system_container.rs
+++ b/crates/bevy_ecs/src/schedule/system_container.rs
@@ -9,6 +9,8 @@ use crate::{
 };
 use std::{borrow::Cow, cell::UnsafeCell};
 
+use super::AmbiguityDetection;
+
 /// System metadata like its name, labels, order requirements and component access.
 pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
     #[doc(hidden)]
@@ -21,6 +23,7 @@ pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
     fn set_run_criteria(&mut self, index: usize);
     fn run_criteria_label(&self) -> Option<&BoxedRunCriteriaLabel>;
     fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel];
+    fn ambiguity_detection(&self) -> &AmbiguityDetection;
     fn component_access(&self) -> Option<&Access<ComponentId>>;
 }
 
@@ -33,6 +36,7 @@ pub(super) struct ExclusiveSystemContainer {
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
     ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    ambiguity_detection: AmbiguityDetection,
 }
 
 impl ExclusiveSystemContainer {
@@ -46,6 +50,7 @@ impl ExclusiveSystemContainer {
             before: descriptor.before,
             after: descriptor.after,
             ambiguity_sets: descriptor.ambiguity_sets,
+            ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
 
@@ -103,6 +108,10 @@ impl SystemContainer for ExclusiveSystemContainer {
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         None
     }
+
+    fn ambiguity_detection(&self) -> &AmbiguityDetection {
+        &self.ambiguity_detection
+    }
 }
 
 pub struct ParallelSystemContainer {
@@ -115,6 +124,7 @@ pub struct ParallelSystemContainer {
     before: Vec<BoxedSystemLabel>,
     after: Vec<BoxedSystemLabel>,
     ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    ambiguity_detection: AmbiguityDetection,
 }
 
 unsafe impl Send for ParallelSystemContainer {}
@@ -133,6 +143,7 @@ impl ParallelSystemContainer {
             before: descriptor.before,
             after: descriptor.after,
             ambiguity_sets: descriptor.ambiguity_sets,
+            ambiguity_detection: descriptor.ambiguity_detection,
         }
     }
 
@@ -214,4 +225,8 @@ impl SystemContainer for ParallelSystemContainer {
     fn component_access(&self) -> Option<&Access<ComponentId>> {
         Some(self.system().component_access())
     }
+
+    fn ambiguity_detection(&self) -> &AmbiguityDetection {
+        &self.ambiguity_detection
+    }
 }
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 74a3963ca26d7..902d5fc0d4ac8 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -90,6 +90,12 @@ impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
     }
 }
 
+pub enum AmbiguityDetection {
+    Check,
+    Ignore,
+    IgnoreWithLabel(Vec<BoxedSystemLabel>),
+}
+
 /// Encapsulates a parallel system and information on when it runs in a `SystemStage`.
 pub struct ParallelSystemDescriptor {
     pub(crate) system: BoxedSystem<(), ()>,
@@ -98,6 +104,7 @@ pub struct ParallelSystemDescriptor {
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
     pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    pub(crate) ambiguity_detection: AmbiguityDetection,
 }
 
 fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescriptor {
@@ -108,6 +115,7 @@ fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescrip
         before: Vec::new(),
         after: Vec::new(),
         ambiguity_sets: Vec::new(),
+        ambiguity_detection: AmbiguityDetection::Check,
     }
 }
 
@@ -131,6 +139,13 @@ pub trait ParallelSystemDescriptorCoercion<Params> {
     /// Specifies that the system is exempt from execution order ambiguity detection
     /// with other systems in this set.
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
+
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor;
+
+    /// Specifies that the system is exempt from execution order ambiguity detection
+    /// with other systems with the given label.
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
 }
 
 impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
@@ -161,6 +176,24 @@ impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
         self.ambiguity_sets.push(Box::new(set));
         self
     }
+
+    fn silence_ambiguity_checks(mut self) -> ParallelSystemDescriptor {
+        self.ambiguity_detection = AmbiguityDetection::Ignore;
+        self
+    }
+
+    fn ambiguous_with(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        match &mut self.ambiguity_detection {
+            AmbiguityDetection::IgnoreWithLabel(v) => {
+                v.push(Box::new(label));
+            }
+            _ => {
+                self.ambiguity_detection =
+                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+            }
+        }
+        self
+    }
 }
 
 impl<S, Params> ParallelSystemDescriptorCoercion<Params> for S
@@ -189,6 +222,14 @@ where
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
         new_parallel_descriptor(Box::new(self.system())).in_ambiguity_set(set)
     }
+
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).silence_ambiguity_checks()
+    }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(Box::new(self.system())).ambiguous_with(label)
+    }
 }
 
 impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
@@ -214,6 +255,14 @@ impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
     fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
         new_parallel_descriptor(self).in_ambiguity_set(set)
     }
+
+    fn silence_ambiguity_checks(self) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).silence_ambiguity_checks()
+    }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
+        new_parallel_descriptor(self).ambiguous_with(label)
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -231,6 +280,7 @@ pub struct ExclusiveSystemDescriptor {
     pub(crate) before: Vec<BoxedSystemLabel>,
     pub(crate) after: Vec<BoxedSystemLabel>,
     pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    pub(crate) ambiguity_detection: AmbiguityDetection,
     pub(crate) insertion_point: InsertionPoint,
 }
 
@@ -242,6 +292,7 @@ fn new_exclusive_descriptor(system: Box<dyn ExclusiveSystem>) -> ExclusiveSystem
         before: Vec::new(),
         after: Vec::new(),
         ambiguity_sets: Vec::new(),
+        ambiguity_detection: AmbiguityDetection::Check,
         insertion_point: InsertionPoint::AtStart,
     }
 }
@@ -276,6 +327,13 @@ pub trait ExclusiveSystemDescriptorCoercion {
 
     /// Specifies that the system should run with other exclusive systems at the end of stage.
     fn at_end(self) -> ExclusiveSystemDescriptor;
+
+    /// Specifies that this system is ambiguous and must be ignored by ambiguity detection.
+    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor;
+
+    /// Specifies that the system is exempt from execution order ambiguity detection
+    /// with other systems with the given label.
+    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
 }
 
 impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
@@ -321,6 +379,24 @@ impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
         self.insertion_point = InsertionPoint::AtEnd;
         self
     }
+
+    fn silence_ambiguity_checks(mut self) -> ExclusiveSystemDescriptor {
+        self.ambiguity_detection = AmbiguityDetection::Ignore;
+        self
+    }
+
+    fn ambiguous_with(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+        match &mut self.ambiguity_detection {
+            AmbiguityDetection::IgnoreWithLabel(v) => {
+                v.push(Box::new(label));
+            }
+            _ => {
+                self.ambiguity_detection =
+                    AmbiguityDetection::IgnoreWithLabel(vec![Box::new(label)]);
+            }
+        }
+        self
+    }
 }
 
 impl<T> ExclusiveSystemDescriptorCoercion for T
@@ -361,4 +437,12 @@ where
     fn at_end(self) -> ExclusiveSystemDescriptor {
         new_exclusive_descriptor(Box::new(self)).at_end()
     }
+
+    fn silence_ambiguity_checks(self) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).silence_ambiguity_checks()
+    }
+
+    fn ambiguous_with(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
+        new_exclusive_descriptor(Box::new(self)).ambiguous_with(label)
+    }
 }
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index e26be98280c1c..2d23bfcc1d3e4 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -13,7 +13,7 @@ pub mod texture;
 pub mod wireframe;
 
 use bevy_ecs::{
-    schedule::{ParallelSystemDescriptorCoercion, SystemStage},
+    schedule::{ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemStage},
     system::{IntoExclusiveSystem, Res},
 };
 use bevy_transform::TransformSystem;
@@ -218,6 +218,11 @@ impl Plugin for RenderPlugin {
                 active_cameras.add(base::camera::CAMERA_2D);
             }
         }
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_render".to_string());
     }
 }
 
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 4dfdb7884979d..04523a844748c 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -28,7 +28,10 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::component::{ComponentDescriptor, StorageType};
+use bevy_ecs::{
+    component::{ComponentDescriptor, StorageType},
+    schedule::ReportExecutionOrderAmbiguities,
+};
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -96,24 +99,32 @@ impl Plugin for SpritePlugin {
             ))
             .unwrap();
 
-        let world_cell = app.world.cell();
-        let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
-        let mut pipelines = world_cell
-            .get_resource_mut::<Assets<PipelineDescriptor>>()
-            .unwrap();
-        let mut shaders = world_cell.get_resource_mut::<Assets<Shader>>().unwrap();
-        crate::render::add_sprite_graph(&mut render_graph, &mut pipelines, &mut shaders);
+        {
+            let world_cell = app.world.cell();
+            let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
+            let mut pipelines = world_cell
+                .get_resource_mut::<Assets<PipelineDescriptor>>()
+                .unwrap();
+            let mut shaders = world_cell.get_resource_mut::<Assets<Shader>>().unwrap();
+            crate::render::add_sprite_graph(&mut render_graph, &mut pipelines, &mut shaders);
 
-        let mut meshes = world_cell.get_resource_mut::<Assets<Mesh>>().unwrap();
-        let mut color_materials = world_cell
-            .get_resource_mut::<Assets<ColorMaterial>>()
-            .unwrap();
-        color_materials.set_untracked(Handle::<ColorMaterial>::default(), ColorMaterial::default());
-        meshes.set_untracked(
-            QUAD_HANDLE,
-            // Use a flipped quad because the camera is facing "forward" but quads should face
-            // backward
-            Mesh::from(shape::Quad::new(Vec2::new(1.0, 1.0))),
-        )
+            let mut meshes = world_cell.get_resource_mut::<Assets<Mesh>>().unwrap();
+            let mut color_materials = world_cell
+                .get_resource_mut::<Assets<ColorMaterial>>()
+                .unwrap();
+            color_materials
+                .set_untracked(Handle::<ColorMaterial>::default(), ColorMaterial::default());
+            meshes.set_untracked(
+                QUAD_HANDLE,
+                // Use a flipped quad because the camera is facing "forward" but quads should face
+                // backward
+                Mesh::from(shape::Quad::new(Vec2::new(1.0, 1.0))),
+            );
+        }
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_sprite".to_string());
     }
 }
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index ce91d4a2e8ba3..759e5cd0633b3 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -29,7 +29,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::entity::Entity;
+use bevy_ecs::{entity::Entity, schedule::ReportExecutionOrderAmbiguities};
 use bevy_render::RenderStage;
 
 pub type DefaultTextPipeline = TextPipeline<Entity>;
@@ -45,5 +45,10 @@ impl Plugin for TextPlugin {
             .insert_resource(DefaultTextPipeline::default())
             .add_system_to_stage(CoreStage::PostUpdate, text2d_system)
             .add_system_to_stage(RenderStage::Draw, text2d::draw_text2d_system);
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_text".to_string());
     }
 }
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index f255c613db814..b690dbfd16084 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -8,7 +8,9 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::schedule::{
+    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
+};
 use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
@@ -48,5 +50,10 @@ impl Plugin for TransformPlugin {
                     .label(TransformSystem::TransformPropagate)
                     .after(TransformSystem::ParentUpdate),
             );
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_transform".to_string());
     }
 }
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index e9ca5b3b328f8..173882303f5a5 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -22,7 +22,9 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::schedule::{
+    ParallelSystemDescriptorCoercion, ReportExecutionOrderAmbiguities, SystemLabel,
+};
 use bevy_input::InputSystem;
 use bevy_math::{Rect, Size};
 use bevy_render::RenderStage;
@@ -85,5 +87,10 @@ impl Plugin for UiPlugin {
             .add_system_to_stage(RenderStage::Draw, widget::draw_text_system);
 
         crate::render::add_ui_graph(&mut app.world);
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_ui".to_string());
     }
 }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index af072b7a60f9f..a939b95be8b47 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -11,7 +11,9 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppExit, CoreStage, Events, ManualEventReader, Plugin};
-use bevy_ecs::{system::IntoExclusiveSystem, world::World};
+use bevy_ecs::{
+    schedule::ReportExecutionOrderAmbiguities, system::IntoExclusiveSystem, world::World,
+};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
@@ -43,6 +45,11 @@ impl Plugin for WinitPlugin {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
+
+        app.world
+            .get_resource_or_insert_with(ReportExecutionOrderAmbiguities::minimal)
+            .ignore_crates
+            .push("bevy_winit".to_string());
     }
 }
 
diff --git a/examples/README.md b/examples/README.md
index 7796afdb16223..e484525f92a59 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -156,6 +156,7 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `ecs_guide` | [`ecs/ecs_guide.rs`](./ecs/ecs_guide.rs) | Full guide to Bevy's ECS
+`ambiguity_checker` | [`ecs/ambiguity_checker.rs`](./ecs/ambiguity_checker.rs) | Shows how to use system order ambiguity checker
 `component_change_detection` | [`ecs/component_change_detection.rs`](./ecs/component_change_detection.rs) | Change detection on components
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception
 `fixed_timestep` | [`ecs/fixed_timestep.rs`](./ecs/fixed_timestep.rs) | Shows how to create systems that run every fixed timestep, rather than every tick
diff --git a/examples/ecs/ambiguity_checker.rs b/examples/ecs/ambiguity_checker.rs
new file mode 100644
index 0000000000000..6c9b1fa0a76d4
--- /dev/null
+++ b/examples/ecs/ambiguity_checker.rs
@@ -0,0 +1,64 @@
+use bevy::{ecs::schedule::ReportExecutionOrderAmbiguities, log::LogPlugin, prelude::*};
+
+fn main() {
+    App::new()
+        // This resource allows to control how Ambiguity Checker will report unresolved ambiguities.
+        // By default only a warning with the number of unresolved ambiguities is shown, but
+        // a more complete report will be displayed if we explicitly set this resource to verbose.
+        // This resource should be added before any bevy internal plugin.
+        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
+        .add_plugin(LogPlugin)
+        .insert_resource(MyStartupResource(0))
+        // `startup_system_a` and `startup_system_b` will both compete for the same resource. Since there is no ordering between
+        // them (e.g., `.before()` or `.after()`), which one will run first is not deterministic.
+        // This ambiguity will be reported by ambiguity checker.
+        .add_startup_system(startup_system_a)
+        .add_startup_system(startup_system_b)
+        .insert_resource(MyResource(0))
+        .insert_resource(MyAnotherResource(0))
+        // It is possible to mark a system as ambiguous if this is intended behavior; the ambiguity checker will ignore this system.
+        .add_system(system_a.silence_ambiguity_checks())
+        .add_system(system_b.label("my_label"))
+        // It is also possible to mark a system as ambiguous with a specific other system,
+        // making the checker ignore any ambiguities between them.
+        .add_system(system_c.ambiguous_with("my_label"))
+        // If there's an whole group of systems that are supposed to be ambiguous with each other,
+        // an ambiguity set can be used to make the checker ignore anything it detects between them.
+        .add_system(system_d.in_ambiguity_set("my_set"))
+        .add_system(system_e.in_ambiguity_set("my_set"))
+        .run();
+}
+
+struct MyStartupResource(i32);
+fn startup_system_a(mut res: ResMut<MyStartupResource>) {
+    res.0 += 1;
+}
+
+fn startup_system_b(mut res: ResMut<MyStartupResource>) {
+    res.0 += 1;
+}
+
+struct MyResource(i32);
+struct MyAnotherResource(i32);
+
+fn system_a(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}
+
+fn system_b(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
+    res.0 += 1;
+    another_res.0 += 1;
+}
+
+fn system_c(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}
+
+fn system_d(mut res: ResMut<MyResource>, mut another_res: ResMut<MyAnotherResource>) {
+    res.0 += 1;
+    another_res.0 += 1;
+}
+
+fn system_e(mut res: ResMut<MyResource>) {
+    res.0 += 1;
+}
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index ae51cb6b3d49a..b5c552cb3a89b 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -343,7 +343,7 @@ fn main() {
         // Be aware that not everything reported by this checker is a potential problem, you'll have
         // to make that judgement yourself.
         .add_plugin(LogPlugin::default())
-        .insert_resource(ReportExecutionOrderAmbiguities)
+        .insert_resource(ReportExecutionOrderAmbiguities::verbose())
         // This call to run() starts the app we just built!
         .run();
 }