diff --git a/Runtime/InteractiveComponent.cs b/Runtime/InteractiveComponent.cs
index 8e3d092..4b8e0f4 100644
--- a/Runtime/InteractiveComponent.cs
+++ b/Runtime/InteractiveComponent.cs
@@ -18,7 +18,7 @@ namespace TestHelper.Monkey
     /// <summary>
     /// Wrapped component that provide interaction for user.
     /// </summary>
-    // TODO: Rename to InteractableComponent
+    [Obsolete]
     public class InteractiveComponent
     {
         /// <summary>
diff --git a/Runtime/InteractiveComponentCollector.cs b/Runtime/InteractiveComponentCollector.cs
index 3641308..b6d6d92 100644
--- a/Runtime/InteractiveComponentCollector.cs
+++ b/Runtime/InteractiveComponentCollector.cs
@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using TestHelper.Monkey.DefaultStrategies;
+using TestHelper.Monkey.Extensions;
 using TestHelper.Monkey.Operators;
 using UnityEngine;
 using UnityEngine.EventSystems;
@@ -47,17 +49,14 @@ public InteractiveComponentCollector(
         ///
         /// Note: If you only need UI elements, using UnityEngine.UI.Selectable.allSelectablesArray is faster.
         /// </summary>
-        /// <returns>Interactive components</returns>
-        public IEnumerable<InteractiveComponent> FindInteractableComponents()
+        /// <returns>Interactable components</returns>
+        public IEnumerable<Component> FindInteractableComponents()
         {
             foreach (var component in FindMonoBehaviours())
             {
                 if (_isInteractable.Invoke(component))
                 {
-                    yield return InteractiveComponent.CreateInteractableComponent(component,
-                        _isReachable,
-                        _isInteractable,
-                        _operators);
+                    yield return component;
                 }
             }
         }
@@ -65,8 +64,7 @@ public IEnumerable<InteractiveComponent> FindInteractableComponents()
         [Obsolete("Use FindInteractableComponents() instead")]
         public static IEnumerable<InteractiveComponent> FindInteractiveComponents()
         {
-            var instance = new InteractiveComponentCollector();
-            return instance.FindInteractableComponents();
+            throw new NotImplementedException("Use FindInteractableComponents() instead");
         }
 
         /// <summary>
@@ -75,24 +73,33 @@ public static IEnumerable<InteractiveComponent> FindInteractiveComponents()
         /// 
         /// Note: If you only need UI elements, using UnityEngine.UI.Selectable.allSelectablesArray is faster.
         /// </summary>
-        /// <returns>Really interactive components</returns>
-        public IEnumerable<InteractiveComponent> FindReachableInteractableComponents()
+        /// <returns>Reachable and Interactable components</returns>
+        public IEnumerable<Component> FindReachableInteractableComponents()
         {
-            foreach (var interactiveComponent in FindInteractableComponents())
+            foreach (var interactableComponent in FindInteractableComponents())
             {
-                if (_isReachable.Invoke(interactiveComponent.gameObject, _eventData, _results))
+                if (_isReachable.Invoke(interactableComponent.gameObject, _eventData, _results))
                 {
-                    yield return interactiveComponent;
+                    yield return interactableComponent;
                 }
             }
         }
 
+        /// <summary>
+        /// Returns tuple of interactable component and operator.
+        /// Note: Not check reachable from user.
+        /// </summary>
+        /// <returns>Tuple of interactable component and operator</returns>
+        public IEnumerable<(Component, IOperator)> FindInteractableComponentsAndOperators()
+        {
+            return FindInteractableComponents().SelectMany(x => x.SelectOperators(_operators), (x, o) => (x, o));
+        }
+
         [Obsolete("Use FindReachableInteractableComponents() instead")]
         public static IEnumerable<InteractiveComponent> FindReallyInteractiveComponents(
             Func<GameObject, Vector2> screenPointStrategy)
         {
-            var instance = new InteractiveComponentCollector();
-            return instance.FindReachableInteractableComponents();
+            throw new NotImplementedException("Use FindReachableInteractableComponents() instead");
         }
 
         private static IEnumerable<MonoBehaviour> FindMonoBehaviours()
diff --git a/Runtime/Monkey.cs b/Runtime/Monkey.cs
index 1a5759b..c8f7d4f 100644
--- a/Runtime/Monkey.cs
+++ b/Runtime/Monkey.cs
@@ -7,11 +7,13 @@
 using System.Threading;
 using Cysharp.Threading.Tasks;
 using TestHelper.Monkey.Annotations;
+using TestHelper.Monkey.Extensions;
 using TestHelper.Monkey.Operators;
 using TestHelper.Random;
 using TestHelper.RuntimeInternals;
 using UnityEngine;
 using UnityEngine.Assertions;
+using UnityEngine.EventSystems;
 
 namespace TestHelper.Monkey
 {
@@ -46,7 +48,7 @@ public static async UniTask Run(MonkeyConfig config, CancellationToken cancellat
                 GameViewControlHelper.SetGizmos(true);
             }
 
-            var interactiveComponentCollector = new InteractiveComponentCollector(
+            var interactableComponentCollector = new InteractiveComponentCollector(
                 isReachable: config.IsReachable,
                 isInteractable: config.IsInteractable,
                 operators: config.Operators);
@@ -57,7 +59,13 @@ public static async UniTask Run(MonkeyConfig config, CancellationToken cancellat
             {
                 while (Time.time < endTime)
                 {
-                    var didAct = await RunStep(config, interactiveComponentCollector, cancellationToken);
+                    var didAct = await RunStep(
+                        config.Random,
+                        config.Logger,
+                        config.Screenshots,
+                        config.IsReachable,
+                        interactableComponentCollector,
+                        cancellationToken);
                     if (didAct)
                     {
                         lastOperationTime = Time.time;
@@ -89,23 +97,29 @@ private class CoroutineRunner : MonoBehaviour
         /// <summary>
         /// Run a step of monkey testing.
         /// </summary>
-        /// <param name="config">Run configuration for monkey testing</param>
-        /// <param name="interactiveComponentCollector"></param>
+        /// <param name="random">Random number generator from <c>MonkeyConfig</c></param>
+        /// <param name="logger">Logger from <c>MonkeyConfig</c></param>
+        /// <param name="screenshotOptions">Take screenshots options from <c>MonkeyConfig</c></param>
+        /// <param name="isReachable">Function returns the <c>GameObject</c> is reachable from user or not. from <c>MonkeyConfig</c></param>
+        /// <param name="interactableComponentCollector">InteractableComponentCollector instance includes isReachable, isInteractable, and operators</param>
         /// <param name="cancellationToken">Cancellation token</param>
-        /// <returns></returns>
+        /// <returns>True if any operator was executed</returns>
         public static async UniTask<bool> RunStep(
-            MonkeyConfig config,
-            InteractiveComponentCollector interactiveComponentCollector,
+            IRandom random,
+            ILogger logger,
+            ScreenshotOptions screenshotOptions,
+            Func<GameObject, PointerEventData, List<RaycastResult>, bool> isReachable,
+            InteractiveComponentCollector interactableComponentCollector,
             CancellationToken cancellationToken = default)
         {
-            var operators = GetOperators(interactiveComponentCollector);
-            var (selectedComponent, selectedOperator) = LotteryOperator(operators.ToList(), config.Random);
+            var operators = GetOperators(interactableComponentCollector);
+            var (selectedComponent, selectedOperator) = LotteryOperator(operators.ToList(), random, isReachable);
             if (selectedComponent == null || selectedOperator == null)
             {
                 return false;
             }
 
-            if (config.Screenshots != null)
+            if (screenshotOptions != null)
             {
                 if (s_coroutineRunner == null || (bool)s_coroutineRunner == false)
                 {
@@ -113,35 +127,32 @@ public static async UniTask<bool> RunStep(
                 }
 
                 await ScreenshotHelper.TakeScreenshot(
-                        directory: config.Screenshots.Directory,
-                        filename: config.Screenshots.FilenameStrategy.GetFilename(),
-                        superSize: config.Screenshots.SuperSize,
-                        stereoCaptureMode: config.Screenshots.StereoCaptureMode
+                        directory: screenshotOptions.Directory,
+                        filename: screenshotOptions.FilenameStrategy.GetFilename(),
+                        superSize: screenshotOptions.SuperSize,
+                        stereoCaptureMode: screenshotOptions.StereoCaptureMode
                     )
                     .ToUniTask(s_coroutineRunner);
             }
 
-            config.Logger.Log($"{selectedOperator} operates to {selectedComponent.gameObject.name}");
-            await selectedOperator.OperateAsync(selectedComponent.component, cancellationToken);
+            logger.Log($"{selectedOperator} operates to {selectedComponent.gameObject.name}");
+            await selectedOperator.OperateAsync(selectedComponent, cancellationToken);
             return true;
         }
 
-        internal static IEnumerable<(InteractiveComponent, IOperator)> GetOperators(
-            InteractiveComponentCollector interactiveComponentCollector)
+        internal static IEnumerable<(Component, IOperator)> GetOperators(InteractiveComponentCollector collector)
         {
-            var components = interactiveComponentCollector.FindInteractableComponents()
-                .Where(x => !x.gameObject.TryGetComponent(typeof(IgnoreAnnotation), out _));
-            return components.SelectMany(x => x.GetOperators(), (x, o) => (x, o));
+            return collector.FindInteractableComponentsAndOperators()
+                .Where(x => !x.Item1.gameObject.TryGetComponent(typeof(IgnoreAnnotation), out _));
         }
 
-        internal static (InteractiveComponent, IOperator) LotteryOperator(
-            List<(InteractiveComponent, IOperator)> operators,
-            IRandom random)
+        internal static (Component, IOperator) LotteryOperator(List<(Component, IOperator)> operators, IRandom random,
+            Func<GameObject, PointerEventData, List<RaycastResult>, bool> isReachable)
         {
             while (operators.Count > 0)
             {
                 var (selectedComponent, selectedOperator) = operators[random.Next(operators.Count)];
-                if (selectedComponent.IsReachable())
+                if (selectedComponent.gameObject.IsReachable(isReachable))
                 {
                     return (selectedComponent, selectedOperator);
                 }
diff --git a/Samples~/uGUI Demo/Tests/Runtime/ScenarioTest.cs b/Samples~/uGUI Demo/Tests/Runtime/ScenarioTest.cs
index 1410c1a..3cf91ef 100644
--- a/Samples~/uGUI Demo/Tests/Runtime/ScenarioTest.cs	
+++ b/Samples~/uGUI Demo/Tests/Runtime/ScenarioTest.cs	
@@ -5,9 +5,8 @@
 using System.Threading.Tasks;
 using NUnit.Framework;
 using TestHelper.Attributes;
+using TestHelper.Monkey.Extensions;
 using TestHelper.Monkey.Operators;
-using UnityEngine;
-using UnityEngine.UI;
 
 namespace TestHelper.Monkey.Samples.UGUIDemo
 {
@@ -30,32 +29,27 @@ public async Task OpenSubScreens(string target)
 
             // When click Start button, then open Home screen.
             var startButton = await _finder.FindByNameAsync("StartButton", interactable: true);
-            var startComponent = CreateInteractableComponent(startButton.GetComponent<Button>());
-            var startClickOperator = startComponent.GetOperatorsByType(OperatorType.Click).First();
-            startClickOperator.OperateAsync(startComponent.component);
+            var startComponent = startButton.GetInteractableComponents().First();
+            var startOperator = startComponent.SelectOperatorsOfType(_config.Operators, OperatorType.Click).First();
+            startOperator.OperateAsync(startComponent);
 
             await _finder.FindByNameAsync("Home");
 
             // When click target button, then open target screen.
             var targetButton = await _finder.FindByNameAsync($"{target}Button", interactable: true);
-            var targetComponent = CreateInteractableComponent(targetButton.GetComponent<Button>());
-            var targetClickOperator = targetComponent.GetOperatorsByType(OperatorType.Click).First();
-            targetClickOperator.OperateAsync(targetComponent.component);
+            var targetComponent = targetButton.GetInteractableComponents().First();
+            var targetOperator = targetComponent.SelectOperatorsOfType(_config.Operators, OperatorType.Click).First();
+            targetOperator.OperateAsync(targetComponent);
 
             await _finder.FindByNameAsync(target);
 
             // When click Back button, then return Home screen.
             var backButton = await _finder.FindByPathAsync($"**/{target}/BackButton", interactable: true);
-            var backComponent = CreateInteractableComponent(backButton.GetComponent<Button>());
-            var backClickOperator = backComponent.GetOperatorsByType(OperatorType.Click).First();
-            backClickOperator.OperateAsync(backComponent.component);
+            var backComponent = backButton.GetInteractableComponents().First();
+            var backOperator = backComponent.SelectOperatorsOfType(_config.Operators, OperatorType.Click).First();
+            backOperator.OperateAsync(backComponent);
 
             await _finder.FindByNameAsync("Home");
         }
-
-        private InteractiveComponent CreateInteractableComponent(MonoBehaviour component)
-        {
-            return InteractiveComponent.CreateInteractableComponent(component, operators: _config.Operators);
-        }
     }
 }
diff --git a/Tests/Runtime/Annotations/PositionAnnotationTest.cs b/Tests/Runtime/Annotations/PositionAnnotationTest.cs
index c671ebe..9970e3c 100644
--- a/Tests/Runtime/Annotations/PositionAnnotationTest.cs
+++ b/Tests/Runtime/Annotations/PositionAnnotationTest.cs
@@ -4,6 +4,8 @@
 using System.Linq;
 using NUnit.Framework;
 using TestHelper.Attributes;
+using TestHelper.Monkey.DefaultStrategies;
+using TestHelper.Monkey.Extensions;
 
 namespace TestHelper.Monkey.Annotations
 {
@@ -31,7 +33,7 @@ string name
             // Without no position annotations, IsReallyInteractiveFromUser() is always false because
             // gameObject.transform.position is not in the mesh. So IsReallyInteractiveFromUser() is true means
             // the position annotation work well
-            Assert.That(target.IsReachable(), Is.True);
+            Assert.That(target.gameObject.IsReachable(DefaultReachableStrategy.IsReachable), Is.True);
         }
     }
 }
diff --git a/Tests/Runtime/InteractiveComponentTest.cs b/Tests/Runtime/InteractiveComponentTest.cs
index 465b7f5..497e600 100644
--- a/Tests/Runtime/InteractiveComponentTest.cs
+++ b/Tests/Runtime/InteractiveComponentTest.cs
@@ -6,6 +6,8 @@
 using System.Threading.Tasks;
 using NUnit.Framework;
 using TestHelper.Attributes;
+using TestHelper.Monkey.DefaultStrategies;
+using TestHelper.Monkey.Extensions;
 using TestHelper.Monkey.Operators;
 using TestHelper.Monkey.TestDoubles;
 using UnityEngine;
@@ -67,7 +69,7 @@ public void IsReachable_reachableObjects_returnTrue(string targetName)
                 var target = new InteractiveComponentCollector().FindInteractableComponents()
                     .First(x => x.gameObject.name == targetName);
 
-                Assert.That(target.IsReachable(), Is.True);
+                Assert.That(target.gameObject.IsReachable(DefaultReachableStrategy.IsReachable), Is.True);
             }
 
             [TestCase("BeyondTheWall")] // Beyond the another object
@@ -78,7 +80,7 @@ public void IsReachable_unreachableObjects_returnFalse(string targetName)
                 var target = new InteractiveComponentCollector().FindInteractableComponents()
                     .First(x => x.gameObject.name == targetName);
 
-                Assert.That(target.IsReachable(), Is.False);
+                Assert.That(target.gameObject.IsReachable(DefaultReachableStrategy.IsReachable), Is.False);
             }
         }
 
@@ -102,7 +104,7 @@ public async Task IsReachable_reachableObjects_returnTrue(string targetName)
                 var target = new InteractiveComponentCollector().FindInteractableComponents()
                     .First(x => x.gameObject.name == targetName);
 
-                Assert.That(target.IsReachable(), Is.True);
+                Assert.That(target.gameObject.IsReachable(DefaultReachableStrategy.IsReachable), Is.True);
             }
 
             [TestCase("BeyondTheWall")] // Beyond the another object
@@ -117,7 +119,7 @@ public async Task IsReachable_unreachableObjects_returnFalse(string targetName)
                 var target = new InteractiveComponentCollector().FindInteractableComponents()
                     .First(x => x.gameObject.name == targetName);
 
-                Assert.That(target.IsReachable(), Is.False);
+                Assert.That(target.gameObject.IsReachable(DefaultReachableStrategy.IsReachable), Is.False);
             }
         }
 
diff --git a/Tests/Runtime/MonkeyTest.cs b/Tests/Runtime/MonkeyTest.cs
index e011d39..f5df96f 100644
--- a/Tests/Runtime/MonkeyTest.cs
+++ b/Tests/Runtime/MonkeyTest.cs
@@ -11,6 +11,7 @@
 using NUnit.Framework;
 using TestHelper.Attributes;
 using TestHelper.Monkey.Annotations;
+using TestHelper.Monkey.DefaultStrategies;
 using TestHelper.Monkey.Operators;
 using TestHelper.Monkey.TestDoubles;
 using TestHelper.Random;
@@ -42,7 +43,12 @@ public async Task RunStep_finish()
             };
 
             var interactiveComponentCollector = new InteractiveComponentCollector(operators: _operators);
-            var didAct = await Monkey.RunStep(config, interactiveComponentCollector);
+            var didAct = await Monkey.RunStep(
+                config.Random,
+                config.Logger,
+                config.Screenshots,
+                config.IsReachable,
+                interactiveComponentCollector);
             Assert.That(didAct, Is.EqualTo(true));
         }
 
@@ -61,7 +67,12 @@ public async Task RunStep_noInteractiveComponent_abort()
                 DelayMillis = 1, // 1ms
             };
 
-            var didAct = await Monkey.RunStep(config, interactiveComponentCollector);
+            var didAct = await Monkey.RunStep(
+                config.Random,
+                config.Logger,
+                config.Screenshots,
+                config.IsReachable,
+                interactiveComponentCollector);
             Assert.That(didAct, Is.EqualTo(false));
         }
 
@@ -200,7 +211,7 @@ public void GetOperators_GotAllInteractableComponentAndOperators()
             foreach (var (component, @operator) in operators)
             {
                 actual.Add(
-                    $"{component.gameObject.name}|{component.component.GetType().Name}|{@operator.GetType().Name}");
+                    $"{component.gameObject.name}|{component.GetType().Name}|{@operator.GetType().Name}");
             }
 
             var expected = new List<string>
@@ -240,9 +251,9 @@ public void GetOperators_WithIgnoreAnnotation_Excluded()
         [Test]
         public void LotteryOperator_NothingOperators_ReturnNull()
         {
-            var operators = new List<(InteractiveComponent, IOperator)>();
+            var operators = new List<(Component, IOperator)>();
             var random = new StubRandom(0);
-            var actual = Monkey.LotteryOperator(operators, random);
+            var actual = Monkey.LotteryOperator(operators, random, DefaultReachableStrategy.IsReachable);
 
             Assert.That(actual.Item1, Is.Null, "InteractiveComponent is null");
             Assert.That(actual.Item2, Is.Null, "Operator is null");
@@ -256,12 +267,9 @@ public void LotteryOperator_NotReachableComponentOnly_ReturnNull()
             var clickable = cube.AddComponent<SpyOnPointerClickHandler>();
             clickable.transform.position = new Vector3(0, 0, -20); // out of sight
 
-            var operators = new List<(InteractiveComponent, IOperator)>()
-            {
-                (InteractiveComponent.CreateInteractableComponent(clickable), new UGUIClickOperator()),
-            };
+            var operators = new List<(Component, IOperator)> { (clickable, new UGUIClickOperator()), };
             var random = new RandomWrapper();
-            var actual = Monkey.LotteryOperator(operators, random);
+            var actual = Monkey.LotteryOperator(operators, random, DefaultReachableStrategy.IsReachable);
 
             Assert.That(actual.Item1, Is.Null, "InteractiveComponent is null");
             Assert.That(actual.Item2, Is.Null, "Operator is null");
@@ -275,16 +283,16 @@ public void LotteryOperator_BingoReachableComponent_ReturnOperator()
             var clickable = cube.AddComponent<SpyOnPointerClickHandler>();
             var clickOperator = new UGUIClickOperator();
 
-            var operators = new List<(InteractiveComponent, IOperator)>()
+            var operators = new List<(Component, IOperator)>()
             {
                 (null, null), // dummy
-                (InteractiveComponent.CreateInteractableComponent(clickable), clickOperator),
+                (clickable, clickOperator),
                 (null, null), // dummy
             };
             var random = new StubRandom(new int[] { 1 });
-            var actual = Monkey.LotteryOperator(operators, random);
+            var actual = Monkey.LotteryOperator(operators, random, DefaultReachableStrategy.IsReachable);
 
-            Assert.That(actual.Item1.component, Is.EqualTo(clickable));
+            Assert.That(actual.Item1, Is.EqualTo(clickable));
             Assert.That(actual.Item2, Is.EqualTo(clickOperator));
         }