diff --git a/src/Copilot.test.ts b/src/Copilot.test.ts
index fe209d3..e6fcd30 100644
--- a/src/Copilot.test.ts
+++ b/src/Copilot.test.ts
@@ -1,7 +1,7 @@
 import { Copilot } from '@/Copilot';
 import { CopilotStepPerformer } from '@/actions/CopilotStepPerformer';
 import { CopilotError } from '@/errors/CopilotError';
-import { Config, ScreenCapturerResult } from '@/types';
+import { Config, ScreenCapturerResult, PromptHandler } from '@/types';
 import { mockCache, mockedCacheFile } from './test-utils/cache';
 import { ScreenCapturer } from '@/utils/ScreenCapturer';
 import {
@@ -10,6 +10,7 @@ import {
   barCategory1,
   dummyContext,
 } from './test-utils/APICatalogTestUtils';
+import { PilotPerformer } from './actions/PilotPerformer';
 
 jest.mock('@/actions/CopilotStepPerformer');
 jest.mock('@/utils/ScreenCapturer');
@@ -21,28 +22,41 @@ const VIEW_HIERARCHY = 'hash';
 
 describe('Copilot', () => {
   let mockConfig: Config;
+  let mockPromptHandler: jest.Mocked<PromptHandler>;
+  let mockFrameworkDriver: any;
+  let mockPilotPerformer: jest.Mocked<PilotPerformer>;
   let screenCapture: ScreenCapturerResult;
 
   beforeEach(() => {
-    mockConfig = {
-      frameworkDriver: {
-        captureSnapshotImage: jest.fn(),
-        captureViewHierarchyString: jest.fn(),
-        apiCatalog: {
-          context: {},
-          categories: [],
-        },
-      },
-      promptHandler: {
-        runPrompt: jest.fn(),
-        isSnapshotImageSupported: jest.fn().mockReturnValue(true),
+    mockPromptHandler = {
+      runPrompt: jest.fn(),
+      isSnapshotImageSupported: jest.fn()
+    } as any;
+
+    mockFrameworkDriver = {
+      apiCatalog: {
+        context: {},
+        categories: []
       },
+      captureSnapshotImage: jest.fn(),
+      captureViewHierarchyString: jest.fn()
     };
 
+    mockPilotPerformer = {
+      perform: jest.fn()
+    } as any;
+
+    mockConfig = {
+      promptHandler: mockPromptHandler,
+      frameworkDriver: mockFrameworkDriver
+    };
+
+    jest.spyOn(PilotPerformer.prototype, 'perform').mockImplementation(mockPilotPerformer.perform);
+
     screenCapture = {
-      snapshot: SNAPSHOT_DATA,
-      viewHierarchy: VIEW_HIERARCHY,
-      isSnapshotImageAttached: true,
+      snapshot: 'base64-encoded-image',
+      viewHierarchy: '<View><Button testID="login" title="Login" /></View>',
+      isSnapshotImageAttached: true
     };
 
     jest.spyOn(console, 'error').mockImplementation(() => {});
@@ -286,17 +300,45 @@ describe('Copilot', () => {
       expect(spyCopilotStepPerformer).toHaveBeenCalledWith(dummyContext);
     });
 
-    it('should extend the API catalog with a new category', () => {
+    it('should extend the API catalog with multiple categories sequentially', () => {
       Copilot.init(mockConfig);
       const instance = Copilot.getInstance();
 
       instance.extendAPICatalog([barCategory1]);
       instance.extendAPICatalog([bazCategory]);
 
-      expect(mockConfig.frameworkDriver.apiCatalog.categories).toEqual([
-        barCategory1,
-        bazCategory,
-      ]);
+      expect(mockConfig.frameworkDriver.apiCatalog.categories).toEqual([barCategory1, bazCategory]);
+    });
+
+    it('should pilot through steps successfully', async () => {
+      Copilot.init(mockConfig);
+      const instance = Copilot.getInstance();
+      const goal = 'test goal';
+
+      const mockPilotResult = {
+        steps: [
+          {
+            plan: {
+              thoughts: "Step 1 thoughts",
+              action: "Tap on GREAT button"
+            },
+            code: "code executed"
+          },
+          {
+            plan: {
+              thoughts: "Completed successfully",
+              action: "success"
+            }
+          }
+        ]
+      };
+
+      mockPilotPerformer.perform.mockResolvedValue(mockPilotResult);
+
+      const pilotResult = await instance.pilot(goal);
+
+      expect(instance['pilotPerformer'].perform).toHaveBeenCalledWith(goal);
+      expect(pilotResult).toEqual(mockPilotResult);
     });
   });
 
@@ -334,4 +376,4 @@ describe('Copilot', () => {
       });
     });
   });
-});
\ No newline at end of file
+});
diff --git a/src/Copilot.ts b/src/Copilot.ts
index 23e41bd..3d665b4 100644
--- a/src/Copilot.ts
+++ b/src/Copilot.ts
@@ -1,13 +1,15 @@
 import {CopilotError} from "@/errors/CopilotError";
-import {PromptCreator} from "@/utils/PromptCreator";
-import {CodeEvaluator} from "@/utils/CodeEvaluator";
-import {SnapshotManager} from "@/utils/SnapshotManager";
-import {CopilotStepPerformer} from "@/actions/CopilotStepPerformer";
-import {Config, PreviousStep, TestingFrameworkAPICatalogCategory, PilotReport, ScreenCapturerResult} from "@/types";
+import {PromptCreator} from './utils/PromptCreator';
+import {CodeEvaluator} from './utils/CodeEvaluator';
+import {SnapshotManager} from './utils/SnapshotManager';
+import {CopilotStepPerformer} from './actions/CopilotStepPerformer';
+import {Config, PreviousStep, TestingFrameworkAPICatalogCategory, PilotReport, ScreenCapturerResult} from './types';
 import {CacheHandler} from "@/utils/CacheHandler";
-import {PilotPerformer} from "@/actions/PilotPerformer";
-import {PilotPromptCreator} from "@/utils/PilotPromptCreator";
-import {ScreenCapturer} from "@/utils/ScreenCapturer";
+import {PilotPerformer} from './actions/PilotPerformer';
+import {PilotPromptCreator} from './utils/PilotPromptCreator';
+import {ScreenCapturer} from './utils/ScreenCapturer';
+import {CopilotAPISearchPromptCreator} from './utils/CopilotAPISearchPromptCreator';
+import {ViewAnalysisPromptCreator} from './utils/ViewAnalysisPromptCreator';
 
 /**
  * The main Copilot class that provides AI-assisted testing capabilities for a given underlying testing framework.
@@ -18,6 +20,7 @@ export class Copilot {
     static instance?: Copilot;
 
     private readonly promptCreator: PromptCreator;
+    private readonly apiSearchPromptCreator: CopilotAPISearchPromptCreator;
     private readonly codeEvaluator: CodeEvaluator;
     private readonly snapshotManager: SnapshotManager;
     private previousSteps: PreviousStep[] = [];
@@ -30,6 +33,7 @@ export class Copilot {
 
     private constructor(config: Config) {
         this.promptCreator = new PromptCreator(config.frameworkDriver.apiCatalog);
+        this.apiSearchPromptCreator = new CopilotAPISearchPromptCreator(config.frameworkDriver.apiCatalog);
         this.codeEvaluator = new CodeEvaluator();
         this.snapshotManager = new SnapshotManager(config.frameworkDriver);
         this.pilotPromptCreator = new PilotPromptCreator();
@@ -38,11 +42,13 @@ export class Copilot {
         this.copilotStepPerformer = new CopilotStepPerformer(
             config.frameworkDriver.apiCatalog.context,
             this.promptCreator,
+            this.apiSearchPromptCreator,
+            new ViewAnalysisPromptCreator(config.frameworkDriver.apiCatalog),
             this.codeEvaluator,
-            this.snapshotManager,
             config.promptHandler,
             this.cacheHandler,
-            config.options?.cacheMode
+            config.options?.cacheMode,
+            config.options?.analysisMode
         );
         this.pilotPerformer = new PilotPerformer(this.pilotPromptCreator, this.copilotStepPerformer, config.promptHandler, this.screenCapturer);
     }
@@ -139,7 +145,7 @@ export class Copilot {
      /**
      * Performs an entire test flow using the provided goal.
      * @param goal A string which describes the flow should be executed.
-     * @returns pilot report with info about the actions thoughts ect ... 
+     * @returns pilot report with info about the actions thoughts ect ...
      */
      async pilot(goal :string) : Promise<PilotReport> {
         return await this.pilotPerformer.perform(goal);
diff --git a/src/actions/CopilotStepPerformer.test.ts b/src/actions/CopilotStepPerformer.test.ts
index f0ddf4b..cf13376 100644
--- a/src/actions/CopilotStepPerformer.test.ts
+++ b/src/actions/CopilotStepPerformer.test.ts
@@ -1,11 +1,12 @@
 import { CopilotStepPerformer } from '@/actions/CopilotStepPerformer';
 import { PromptCreator } from '@/utils/PromptCreator';
 import { CodeEvaluator } from '@/utils/CodeEvaluator';
-import { SnapshotManager } from '@/utils/SnapshotManager';
 import { CacheHandler } from '@/utils/CacheHandler';
 import { PromptHandler, TestingFrameworkAPICatalog, ScreenCapturerResult, PreviousStep, CacheMode } from '@/types';
 import * as crypto from 'crypto';
-import { dummyContext, dummyBarContext1, dummyBarContext2 } from '../test-utils/APICatalogTestUtils';
+import {dummyContext, dummyBarContext1, dummyBarContext2} from '../test-utils/APICatalogTestUtils';
+import {CopilotAPISearchPromptCreator} from '@/utils/CopilotAPISearchPromptCreator';
+import {ViewAnalysisPromptCreator} from '@/utils/ViewAnalysisPromptCreator';
 
 jest.mock('fs');
 jest.mock('crypto');
@@ -15,15 +16,14 @@ const VIEW_HIERARCHY = '<view></view>';
 const PROMPT_RESULT = 'generated code';
 const CODE_EVALUATION_RESULT = 'success';
 const SNAPSHOT_DATA = 'snapshot_data';
-const VIEW_HIERARCHY_HASH = 'hash';
-const CACHE_KEY = JSON.stringify({ step: INTENT, previous: [], viewHierarchyHash: VIEW_HIERARCHY_HASH });
 
 describe('CopilotStepPerformer', () => {
   let copilotStepPerformer: CopilotStepPerformer;
   let mockContext: jest.Mocked<any>;
   let mockPromptCreator: jest.Mocked<PromptCreator>;
+  let mockApiSearchPromptCreator: jest.Mocked<CopilotAPISearchPromptCreator>;
+  let mockViewAnalysisPromptCreator: jest.Mocked<ViewAnalysisPromptCreator>;
   let mockCodeEvaluator: jest.Mocked<CodeEvaluator>;
-  let mockSnapshotManager: jest.Mocked<SnapshotManager>;
   let mockPromptHandler: jest.Mocked<PromptHandler>;
   let mockCacheHandler: jest.Mocked<CacheHandler>;
   let uuidCounter = 0;
@@ -31,7 +31,7 @@ describe('CopilotStepPerformer', () => {
   beforeEach(() => {
     jest.resetAllMocks();
     uuidCounter = 0;
-        (crypto.randomUUID as jest.Mock).mockImplementation(() => `uuid-${uuidCounter++}`);
+    (crypto.randomUUID as jest.Mock).mockImplementation(() => `uuid-${uuidCounter++}`);
     const apiCatalog: TestingFrameworkAPICatalog = {
       context: {},
       categories: [],
@@ -46,17 +46,21 @@ describe('CopilotStepPerformer', () => {
       createBasePrompt: jest.fn(),
       createContext: jest.fn(),
       createAPIInfo: jest.fn(),
+      extendAPICategories: jest.fn(),
     } as unknown as jest.Mocked<PromptCreator>;
 
+    mockApiSearchPromptCreator = {
+      createPrompt: jest.fn(),
+    } as unknown as jest.Mocked<CopilotAPISearchPromptCreator>;
+
+    mockViewAnalysisPromptCreator = {
+      createPrompt: jest.fn(),
+    } as unknown as jest.Mocked<ViewAnalysisPromptCreator>;
+
     mockCodeEvaluator = {
       evaluate: jest.fn(),
     } as unknown as jest.Mocked<CodeEvaluator>;
 
-    mockSnapshotManager = {
-      captureSnapshotImage: jest.fn(),
-      captureViewHierarchyString: jest.fn(),
-    } as unknown as jest.Mocked<SnapshotManager>;
-
     mockPromptHandler = {
       runPrompt: jest.fn(),
       isSnapshotImageSupported: jest.fn(),
@@ -70,15 +74,19 @@ describe('CopilotStepPerformer', () => {
       flushTemporaryCache: jest.fn(),
       clearTemporaryCache: jest.fn(),
       getStepFromCache: jest.fn(),
+      getFromTemporaryCache: jest.fn(),
     } as unknown as jest.Mocked<CacheHandler>;
 
     copilotStepPerformer = new CopilotStepPerformer(
-      mockContext,
-      mockPromptCreator,
-      mockCodeEvaluator,
-      mockSnapshotManager,
-      mockPromptHandler,
-      mockCacheHandler
+        mockContext,
+        mockPromptCreator,
+        mockApiSearchPromptCreator,
+        mockViewAnalysisPromptCreator,
+        mockCodeEvaluator,
+        mockPromptHandler,
+        mockCacheHandler,
+        'full',
+        'fast'
     );
   });
 
@@ -95,19 +103,17 @@ describe('CopilotStepPerformer', () => {
   }
 
   const setupMocks = ({
-    isSnapshotSupported = true,
-    snapshotData = SNAPSHOT_DATA,
-    viewHierarchy = VIEW_HIERARCHY,
-    promptResult = PROMPT_RESULT,
-    codeEvaluationResult = CODE_EVALUATION_RESULT,
-    cacheExists = false,
-    overrideCache = false,
-    previous = [],
-    intent = INTENT,
-  }: SetupMockOptions = {}) => {
+                        isSnapshotSupported = true,
+                        snapshotData = SNAPSHOT_DATA,
+                        viewHierarchy = VIEW_HIERARCHY,
+                        promptResult = PROMPT_RESULT,
+                        codeEvaluationResult = CODE_EVALUATION_RESULT,
+                        cacheExists = false,
+                        overrideCache = false,
+                        previous = [],
+                        intent = INTENT,
+                      }: SetupMockOptions = {}) => {
     mockPromptHandler.isSnapshotImageSupported.mockReturnValue(isSnapshotSupported);
-    mockSnapshotManager.captureSnapshotImage.mockResolvedValue(snapshotData != null ? snapshotData : undefined);
-    mockSnapshotManager.captureViewHierarchyString.mockResolvedValue(viewHierarchy);
     mockPromptCreator.createPrompt.mockReturnValue('generated prompt');
     mockPromptHandler.runPrompt.mockResolvedValue(promptResult);
     mockCodeEvaluator.evaluate.mockResolvedValue(codeEvaluationResult);
@@ -145,91 +151,74 @@ describe('CopilotStepPerformer', () => {
 
   it('should perform an intent successfully with snapshot image support', async () => {
     setupMocks();
-
-    const screenCapture: ScreenCapturerResult = {
-      snapshot: SNAPSHOT_DATA,
-      viewHierarchy: VIEW_HIERARCHY,
-      isSnapshotImageAttached: true,
-    };
-
-    const result = await copilotStepPerformer.perform(INTENT, [], screenCapture, 2);
+    const result = await copilotStepPerformer.perform(INTENT, [], {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true
+    });
 
     expect(mockCacheHandler.loadCacheFromFile).toHaveBeenCalled();
     expect(result).toBe('success');
-    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, true, []);
+    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, true, [], '');
     expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith('generated prompt', SNAPSHOT_DATA);
     expect(mockCodeEvaluator.evaluate).toHaveBeenCalledWith(PROMPT_RESULT, mockContext);
     expect(mockCacheHandler.getStepFromCache).toHaveBeenCalled();
-    expect(mockCacheHandler.addToTemporaryCache).toHaveBeenCalled();
   });
 
   it('should perform an intent successfully without snapshot image support', async () => {
-    setupMocks({ isSnapshotSupported: false });
-
-    const screenCapture: ScreenCapturerResult = {
-      snapshot: undefined,
-      viewHierarchy: VIEW_HIERARCHY,
-      isSnapshotImageAttached: false,
-    };
-
-    const result = await copilotStepPerformer.perform(INTENT, [], screenCapture, 2);
+    setupMocks();
+    mockPromptHandler.isSnapshotImageSupported.mockReturnValue(false);
+    const result = await copilotStepPerformer.perform(INTENT, [], {
+        snapshot: undefined,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: false
+    });
 
     expect(mockCacheHandler.loadCacheFromFile).toHaveBeenCalled();
     expect(result).toBe('success');
-    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, false, []);
+    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, false, [], '');
     expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith('generated prompt', undefined);
     expect(mockCodeEvaluator.evaluate).toHaveBeenCalledWith(PROMPT_RESULT, mockContext);
     expect(mockCacheHandler.getStepFromCache).toHaveBeenCalled();
-    expect(mockCacheHandler.addToTemporaryCache).toHaveBeenCalled();
   });
 
   it('should perform an intent with undefined snapshot', async () => {
-    setupMocks({ snapshotData: null });
-
-    const screenCapture: ScreenCapturerResult = {
-      snapshot: undefined,
-      viewHierarchy: VIEW_HIERARCHY,
-      isSnapshotImageAttached: false,
-    };
-
-    const result = await copilotStepPerformer.perform(INTENT, [], screenCapture, 2);
+    setupMocks();
+    const result = await copilotStepPerformer.perform(INTENT, [], {
+        snapshot: undefined,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: false
+    });
 
     expect(mockCacheHandler.loadCacheFromFile).toHaveBeenCalled();
     expect(result).toBe('success');
-    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, false, []);
+    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, false, [], '');
     expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith('generated prompt', undefined);
     expect(mockCodeEvaluator.evaluate).toHaveBeenCalledWith(PROMPT_RESULT, mockContext);
     expect(mockCacheHandler.getStepFromCache).toHaveBeenCalled();
-    expect(mockCacheHandler.addToTemporaryCache).toHaveBeenCalled();
   });
 
   it('should perform an intent successfully with previous intents', async () => {
+    setupMocks();
     const intent = 'current intent';
-    const previousIntents: PreviousStep[] = [
-      {
+    const previousIntents = [{
         step: 'previous intent',
         code: 'previous code',
-        result: 'previous result',
-      },
-    ];
+        result: 'previous result'
+    }];
 
-    setupMocks({ previous: previousIntents, intent });
-
-    const screenCapture: ScreenCapturerResult = {
-      snapshot: SNAPSHOT_DATA,
-      viewHierarchy: VIEW_HIERARCHY,
-      isSnapshotImageAttached: true,
-    };
-
-    const result = await copilotStepPerformer.perform(intent, previousIntents, screenCapture, 2);
+    const result = await copilotStepPerformer.perform(intent, previousIntents, {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true
+    });
 
     expect(mockCacheHandler.loadCacheFromFile).toHaveBeenCalled();
     expect(result).toBe('success');
-    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(intent, VIEW_HIERARCHY, true, previousIntents);
+    expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(intent, VIEW_HIERARCHY, true, previousIntents, '');
     expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith('generated prompt', SNAPSHOT_DATA);
     expect(mockCodeEvaluator.evaluate).toHaveBeenCalledWith(PROMPT_RESULT, mockContext);
     expect(mockCacheHandler.getStepFromCache).toHaveBeenCalled();
-    expect(mockCacheHandler.addToTemporaryCache).toHaveBeenCalled();
   });
 
   it('should throw an error if code evaluation fails', async () => {
@@ -377,75 +366,160 @@ describe('CopilotStepPerformer', () => {
   });
   describe('cache modes', () => {
     const testCacheModes = async (cacheMode: CacheMode) => {
-        const generatedKeys: string[] = [];
-        mockCacheHandler.addToTemporaryCache.mockImplementation((key: string) => {
-            generatedKeys.push(key);
-        });
-
-        copilotStepPerformer = new CopilotStepPerformer(
-            mockContext,
-            mockPromptCreator,
-            mockCodeEvaluator,
-            mockSnapshotManager,
-            mockPromptHandler,
-            mockCacheHandler,
-            cacheMode
-        );
-        const screenCapture: ScreenCapturerResult = {
-            snapshot: SNAPSHOT_DATA,
-            viewHierarchy: VIEW_HIERARCHY,
-            isSnapshotImageAttached: true,
-          }; 
-
-        setupMocks({
-            promptResult: '```\nconst code = true;\n```',
-            codeEvaluationResult: 'success'
-        });
-        await copilotStepPerformer.perform(INTENT, [], screenCapture, undefined);
-        return generatedKeys[0];
+      const generatedKeys: string[] = [];
+      mockCacheHandler.addToTemporaryCache.mockImplementation((key: string) => {
+        generatedKeys.push(key);
+      });
+
+      copilotStepPerformer = new CopilotStepPerformer(
+          mockContext,
+          mockPromptCreator,
+          mockApiSearchPromptCreator,
+          mockViewAnalysisPromptCreator,
+          mockCodeEvaluator,
+          mockPromptHandler,
+          mockCacheHandler,
+          cacheMode,
+          'fast'
+      );
+      const screenCapture: ScreenCapturerResult = {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true,
+      };
+
+      setupMocks({
+        promptResult: '```\nconst code = true;\n```',
+        codeEvaluationResult: 'success'
+      });
+      await copilotStepPerformer.perform(INTENT, [], screenCapture, undefined);
+      return generatedKeys[0];
     };
 
     it('should include view hierarchy hash in cache key when mode is full', async () => {
-        const cacheKey = await testCacheModes('full');
-        const parsedKey = JSON.parse(cacheKey);
-        expect(parsedKey).toHaveProperty('viewHierarchyHash');
-        expect(parsedKey.viewHierarchyHash).toBe('hash');
+      const cacheKey = await testCacheModes('full');
+      const parsedKey = JSON.parse(cacheKey);
+      expect(parsedKey).toHaveProperty('viewHierarchyHash');
+      expect(parsedKey.viewHierarchyHash).toBe('hash');
     });
 
     it('should not include view hierarchy hash in cache key when mode is lightweight', async () => {
-        const cacheKey = await testCacheModes('lightweight');
-        const parsedKey = JSON.parse(cacheKey);
-        expect(parsedKey).not.toHaveProperty('viewHierarchyHash');
+      const cacheKey = await testCacheModes('lightweight');
+      const parsedKey = JSON.parse(cacheKey);
+      expect(parsedKey).not.toHaveProperty('viewHierarchyHash');
     });
 
     it('should generate unique cache keys when mode is disabled', async () => {
-        const firstKey = await testCacheModes('disabled');
-        const secondKey = await testCacheModes('disabled');
-        expect(firstKey).not.toBe(secondKey);
+      const firstKey = await testCacheModes('disabled');
+      const secondKey = await testCacheModes('disabled');
+      expect(firstKey).not.toBe(secondKey);
     });
 
     it('should not use cache when mode is disabled', async () => {
 
-        const screenCapture: ScreenCapturerResult = {
-            snapshot: SNAPSHOT_DATA,
-            viewHierarchy: VIEW_HIERARCHY,
-            isSnapshotImageAttached: true,
-          }; 
-
-        copilotStepPerformer = new CopilotStepPerformer(
-            mockContext,
-            mockPromptCreator,
-            mockCodeEvaluator,
-            mockSnapshotManager,
-            mockPromptHandler,
-            mockCacheHandler,
-            'disabled'
-        );
-
-        setupMocks({ cacheExists: true });
-        await copilotStepPerformer.perform(INTENT, [], screenCapture, undefined);
-
-        expect(mockPromptHandler.runPrompt).toHaveBeenCalled();
+      const screenCapture: ScreenCapturerResult = {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true,
+      };
+
+      copilotStepPerformer = new CopilotStepPerformer(
+          mockContext,
+          mockPromptCreator,
+          mockApiSearchPromptCreator,
+          mockViewAnalysisPromptCreator,
+          mockCodeEvaluator,
+          mockPromptHandler,
+          mockCacheHandler,
+          'disabled',
+          'fast'
+      );
+
+      setupMocks({ cacheExists: true });
+      await copilotStepPerformer.perform(INTENT, [], screenCapture, undefined);
+
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalled();
     });
+  });
+
+  describe('analysis modes', () => {
+    it('should perform full analysis in full mode', async () => {
+      setupMocks();
+      const viewAnalysisResult = 'view analysis result';
+      const apiSearchResult = 'api search result';
+
+      mockViewAnalysisPromptCreator.createPrompt.mockReturnValue('view analysis prompt');
+      mockApiSearchPromptCreator.createPrompt.mockReturnValue('api search prompt');
+      mockPromptHandler.runPrompt
+          .mockResolvedValueOnce(viewAnalysisResult)
+          .mockResolvedValueOnce(apiSearchResult)
+          .mockResolvedValueOnce(PROMPT_RESULT);
+
+      copilotStepPerformer = new CopilotStepPerformer(
+          mockContext,
+          mockPromptCreator,
+          mockApiSearchPromptCreator,
+          mockViewAnalysisPromptCreator,
+          mockCodeEvaluator,
+          mockPromptHandler,
+          mockCacheHandler,
+          'full',
+          'full'
+      );
+
+      const screenCapture: ScreenCapturerResult = {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true
+      };
+
+      const result = await copilotStepPerformer.perform(INTENT, [], screenCapture);
+
+      expect(result).toBe(CODE_EVALUATION_RESULT);
+      expect(mockViewAnalysisPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, VIEW_HIERARCHY, []);
+      expect(mockApiSearchPromptCreator.createPrompt).toHaveBeenCalledWith(INTENT, viewAnalysisResult);
+      expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(
+          INTENT,
+          VIEW_HIERARCHY,
+          true,
+          [],
+          apiSearchResult
+      );
+    });
+
+    it('should skip analysis in fast mode', async () => {
+      setupMocks();
+
+      copilotStepPerformer = new CopilotStepPerformer(
+          mockContext,
+          mockPromptCreator,
+          mockApiSearchPromptCreator,
+          mockViewAnalysisPromptCreator,
+          mockCodeEvaluator,
+          mockPromptHandler,
+          mockCacheHandler,
+          'full',
+          'fast'
+      );
+
+      const screenCapture: ScreenCapturerResult = {
+        snapshot: SNAPSHOT_DATA,
+        viewHierarchy: VIEW_HIERARCHY,
+        isSnapshotImageAttached: true
+      };
+
+      const result = await copilotStepPerformer.perform(INTENT, [], screenCapture);
+
+      expect(result).toBe(CODE_EVALUATION_RESULT);
+      expect(mockViewAnalysisPromptCreator.createPrompt).not.toHaveBeenCalled();
+      expect(mockApiSearchPromptCreator.createPrompt).not.toHaveBeenCalled();
+      expect(mockPromptCreator.createPrompt).toHaveBeenCalledWith(
+          INTENT,
+          VIEW_HIERARCHY,
+          true,
+          [],
+          ''
+      );
+    });
+  });
 });
-});
\ No newline at end of file
diff --git a/src/actions/CopilotStepPerformer.ts b/src/actions/CopilotStepPerformer.ts
index 8642b49..5d4f3ac 100644
--- a/src/actions/CopilotStepPerformer.ts
+++ b/src/actions/CopilotStepPerformer.ts
@@ -1,27 +1,29 @@
 import {PromptCreator} from '@/utils/PromptCreator';
 import {CodeEvaluator} from '@/utils/CodeEvaluator';
-import {SnapshotManager} from '@/utils/SnapshotManager';
+import {CopilotAPISearchPromptCreator} from '@/utils/CopilotAPISearchPromptCreator';
+import {ViewAnalysisPromptCreator} from '@/utils/ViewAnalysisPromptCreator';
 import {CacheHandler} from '@/utils/CacheHandler';
-import {CacheMode, CodeEvaluationResult, PreviousStep, PromptHandler, ScreenCapturerResult} from '@/types';
-import * as fs from 'fs';
-import * as path from 'path';
+import {AnalysisMode, CacheMode, CodeEvaluationResult, PreviousStep, PromptHandler, ScreenCapturerResult} from '@/types';
 import * as crypto from 'crypto';
 import {extractCodeBlock} from '@/utils/extractCodeBlock';
 
 export class CopilotStepPerformer {
     private readonly cacheMode: CacheMode;
-    
+    private readonly analysisMode: AnalysisMode;
 
     constructor(
         private context: any,
         private promptCreator: PromptCreator,
+        private apiSearchPromptCreator: CopilotAPISearchPromptCreator,
+        private viewAnalysisPromptCreator: ViewAnalysisPromptCreator,
         private codeEvaluator: CodeEvaluator,
-        private snapshotManager: SnapshotManager,
         private promptHandler: PromptHandler,
         private cacheHandler: CacheHandler,
         cacheMode: CacheMode = 'full',
+        analysisMode: AnalysisMode = 'fast',
     ) {
         this.cacheMode = cacheMode;
+        this.analysisMode = analysisMode;
     }
 
     extendJSContext(newContext: any): void {
@@ -41,7 +43,7 @@ export class CopilotStepPerformer {
         }
 
         const cacheKeyData: any = {step, previous};
-        
+
         if (this.cacheMode === 'full') {
             const viewHierarchyHash = crypto.createHash('md5').update(viewHierarchy).digest('hex');
             cacheKeyData.viewHierarchyHash = viewHierarchyHash;
@@ -57,7 +59,7 @@ export class CopilotStepPerformer {
     private async generateCode(
         step: string,
         previous: PreviousStep[],
-        snapshot: any,
+        snapshot: string | undefined,
         viewHierarchy: string,
         isSnapshotImageAttached: boolean,
     ): Promise<string> {
@@ -67,7 +69,30 @@ export class CopilotStepPerformer {
         if (!this.shouldOverrideCache() && cachedCode) {
             return cachedCode;
         } else {
-            const prompt = this.promptCreator.createPrompt(step, viewHierarchy, isSnapshotImageAttached, previous);
+            let viewAnalysisResult = '';
+            let apiSearchResult = '';
+
+            if (this.analysisMode === 'full') {
+                // Perform view hierarchy analysis and API search only in full mode
+                viewAnalysisResult = await this.promptHandler.runPrompt(
+                    this.viewAnalysisPromptCreator.createPrompt(step, viewHierarchy, previous),
+                    undefined
+                );
+
+                apiSearchResult = await this.promptHandler.runPrompt(
+                    this.apiSearchPromptCreator.createPrompt(step, viewAnalysisResult),
+                    undefined
+                );
+            }
+
+            const prompt = this.promptCreator.createPrompt(
+                step,
+                viewHierarchy,
+                isSnapshotImageAttached,
+                previous,
+                apiSearchResult
+            );
+
             const promptResult = await this.promptHandler.runPrompt(prompt, snapshot);
             const code = extractCodeBlock(promptResult);
 
diff --git a/src/integration tests/index.test.ts b/src/integration tests/index.test.ts
index 81524ea..c5c4aef 100644
--- a/src/integration tests/index.test.ts	
+++ b/src/integration tests/index.test.ts	
@@ -92,8 +92,8 @@ describe('Copilot Integration Tests', () => {
       expect(mockFrameworkDriver.captureSnapshotImage).toHaveBeenCalled();
       expect(mockFrameworkDriver.captureViewHierarchyString).toHaveBeenCalled();
       expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith(
-        expect.stringContaining('Tap on the login button'),
-        'mock_snapshot'
+          expect.stringContaining('Tap on the login button'),
+          'mock_snapshot'
       );
     });
 
@@ -105,8 +105,8 @@ describe('Copilot Integration Tests', () => {
       expect(mockFrameworkDriver.captureSnapshotImage).toHaveBeenCalled();
       expect(mockFrameworkDriver.captureViewHierarchyString).toHaveBeenCalled();
       expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith(
-        expect.stringContaining('The welcome message should be visible'),
-        'mock_snapshot'
+          expect.stringContaining('The welcome message should be visible'),
+          'mock_snapshot'
       );
     });
 
@@ -140,14 +140,14 @@ describe('Copilot Integration Tests', () => {
 
     it('should perform multiple steps using spread operator', async () => {
       mockPromptHandler.runPrompt
-        .mockResolvedValueOnce('// Tap login button')
-        .mockResolvedValueOnce('// Enter username')
-        .mockResolvedValueOnce('// Enter password');
+          .mockResolvedValueOnce('// Tap login button')
+          .mockResolvedValueOnce('// Enter username')
+          .mockResolvedValueOnce('// Enter password');
 
       await copilot.perform(
-        'Tap on the login button',
-        'Enter username "testuser"',
-        'Enter password "password123"'
+          'Tap on the login button',
+          'Enter username "testuser"',
+          'Enter password "password123"'
       );
 
       expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(3);
@@ -157,20 +157,20 @@ describe('Copilot Integration Tests', () => {
 
     it('should handle errors in multiple steps and stop execution', async () => {
       mockPromptHandler.runPrompt
-        .mockResolvedValueOnce('// Tap login button')
-        .mockResolvedValueOnce('throw new Error("Username field not found");')
-        .mockResolvedValueOnce('throw new Error("Username field not found - second");')
-        .mockResolvedValueOnce('// Enter password');
+          .mockResolvedValueOnce('// Tap login button')
+          .mockResolvedValueOnce('throw new Error("Username field not found");')
+          .mockResolvedValueOnce('throw new Error("Username field not found - second");')
+          .mockResolvedValueOnce('// Enter password');
 
       await expect(
-        copilot.perform(
-          'Tap on the login button',
-          'Enter username "testuser"',
-          'Enter password "password123"'
-        )
+          copilot.perform(
+              'Tap on the login button',
+              'Enter username "testuser"',
+              'Enter password "password123"'
+          )
       ).rejects.toThrow('Username field not found');
 
-      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(3); 
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(3);
       expect(mockFrameworkDriver.captureSnapshotImage).toHaveBeenCalledTimes(2);
       expect(mockFrameworkDriver.captureViewHierarchyString).toHaveBeenCalledTimes(2);
     });
@@ -229,8 +229,8 @@ describe('Copilot Integration Tests', () => {
 
     it('should clear conversation history on reset', async () => {
       mockPromptHandler.runPrompt
-        .mockResolvedValueOnce('// Action 1')
-        .mockResolvedValueOnce('// Action 2');
+          .mockResolvedValueOnce('// Action 1')
+          .mockResolvedValueOnce('// Action 2');
 
       await copilot.perform('Action 1');
       await copilot.perform('Action 2');
@@ -334,8 +334,8 @@ describe('Copilot Integration Tests', () => {
       expect(mockFrameworkDriver.captureSnapshotImage).not.toHaveBeenCalled();
       expect(mockFrameworkDriver.captureViewHierarchyString).toHaveBeenCalled();
       expect(mockPromptHandler.runPrompt).toHaveBeenCalledWith(
-        expect.stringContaining('Perform action without snapshot support'),
-        undefined
+          expect.stringContaining('Perform action without snapshot support'),
+          undefined
       );
     });
   });
@@ -351,8 +351,8 @@ describe('Copilot Integration Tests', () => {
     });
 
     it('should call relevant functions to extend the catalog', () => {
-     const spyPromptCreator = jest.spyOn(PromptCreator.prototype, 'extendAPICategories');
-     const spyCopilotStepPerformer = jest.spyOn(CopilotStepPerformer.prototype, 'extendJSContext');
+      const spyPromptCreator = jest.spyOn(PromptCreator.prototype, 'extendAPICategories');
+      const spyCopilotStepPerformer = jest.spyOn(CopilotStepPerformer.prototype, 'extendJSContext');
 
       copilot.extendAPICatalog([bazCategory]);
       expect(spyPromptCreator).toHaveBeenCalledTimes(1);
@@ -397,8 +397,8 @@ describe('Copilot Integration Tests', () => {
       };
       const copilotInstance = Copilot.getInstance();
       const spyPilotPerformerPerform = jest
-        .spyOn(copilotInstance['pilotPerformer'], 'perform')
-        .mockResolvedValue(mockPilotReport);
+          .spyOn(copilotInstance['pilotPerformer'], 'perform')
+          .mockResolvedValue(mockPilotReport);
 
       const result = await copilot.pilot(goal);
 
@@ -413,8 +413,8 @@ describe('Copilot Integration Tests', () => {
       const errorMessage = 'Error during pilot execution';
       const copilotInstance = Copilot.getInstance();
       const spyPilotPerformerPerform = jest
-        .spyOn(copilotInstance['pilotPerformer'], 'perform')
-        .mockRejectedValue(new Error(errorMessage));
+          .spyOn(copilotInstance['pilotPerformer'], 'perform')
+          .mockRejectedValue(new Error(errorMessage));
 
       await expect(copilot.pilot(goal)).rejects.toThrow(errorMessage);
 
@@ -422,62 +422,115 @@ describe('Copilot Integration Tests', () => {
       expect(spyPilotPerformerPerform).toHaveBeenCalledWith(goal);
     });
   });
-    describe('Cache Modes', () => {
-        beforeEach(() => {
-            mockPromptHandler.runPrompt.mockResolvedValue('// No operation');
-        });
 
-        it('should use full cache mode by default', async () => {
-            copilot.init({
-                frameworkDriver: mockFrameworkDriver,
-                promptHandler: mockPromptHandler
-            });
-            copilot.start();
+  describe('Cache Modes', () => {
+    beforeEach(() => {
+      mockPromptHandler.runPrompt.mockResolvedValue('// No operation');
+    });
 
-            await copilot.perform('Tap on the login button');
-            copilot.end();
+    it('should use full cache mode by default', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler
+      });
+      copilot.start();
 
-            expect(Object.keys(mockedCacheFile || {})[0]).toContain('viewHierarchyHash');
-        });
+      await copilot.perform('Tap on the login button');
+      copilot.end();
 
-        it('should not include view hierarchy in cache key when using lightweight mode', async () => {
-            copilot.init({
-                frameworkDriver: mockFrameworkDriver,
-                promptHandler: mockPromptHandler,
-                options: {
-                    cacheMode: 'lightweight'
-                }
-            });
-            copilot.start();
-
-            await copilot.perform('Tap on the login button');
-            copilot.end();
-
-            const cacheKeys = Object.keys(mockedCacheFile || {});
-            expect(cacheKeys[0]).not.toContain('viewHierarchyHash');
-        });
+      expect(Object.keys(mockedCacheFile || {})[0]).toContain('viewHierarchyHash');
+    });
 
-        it('should not use cache when cache mode is disabled', async () => {
-            copilot.init({
-                frameworkDriver: mockFrameworkDriver,
-                promptHandler: mockPromptHandler,
-                options: {
-                    cacheMode: 'disabled'
-                }
-            });
-            copilot.start();
-
-            // First call
-            await copilot.perform('Tap on the login button');
-            copilot.end();
-
-            // Second call with same intent
-            copilot.start();
-            await copilot.perform('Tap on the login button');
-            copilot.end();
-
-            // Should call runPrompt twice since cache is disabled
-            expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(2);
-        });
+    it('should not include view hierarchy in cache key when using lightweight mode', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler,
+        options: {
+          cacheMode: 'lightweight'
+        }
+      });
+      copilot.start();
+
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      const cacheKeys = Object.keys(mockedCacheFile || {});
+      expect(cacheKeys[0]).not.toContain('viewHierarchyHash');
     });
+
+    it('should not use cache when cache mode is disabled', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler,
+        options: {
+          cacheMode: 'disabled'
+        }
+      });
+      copilot.start();
+
+      // First call
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      // Second call with same intent
+      copilot.start();
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      // Should call runPrompt twice since cache is disabled
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('Analysis Modes', () => {
+    beforeEach(() => {
+        mockPromptHandler.runPrompt.mockResolvedValue('// No operation');
+    });
+
+    it('should perform fast analysis by default', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler
+      });
+
+      copilot.start();
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(1);
+    });
+
+    it('should perform fast analysis when specified', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler,
+        options: {
+          analysisMode: 'fast'
+        }
+      });
+
+      copilot.start();
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(1);
+    });
+
+    it('should perform full analysis when specified', async () => {
+      copilot.init({
+        frameworkDriver: mockFrameworkDriver,
+        promptHandler: mockPromptHandler,
+        options: {
+          analysisMode: 'full'
+        }
+      });
+
+      copilot.start();
+      await copilot.perform('Tap on the login button');
+      copilot.end();
+
+      // requires several prompts to be run
+      expect(mockPromptHandler.runPrompt).toHaveBeenCalledTimes(3);
+    });
+  });
 });
diff --git a/src/types.ts b/src/types.ts
index 998f61f..b14e0ab 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -157,6 +157,14 @@ export interface PromptHandler {
  * @default 'full'
  */
 export type CacheMode = 'full' | 'lightweight' | 'disabled';
+/**
+ * The analysis mode for the Copilot.
+ *  - 'fast': Skip API search and view hierarchy analysis preprocessing (default)
+ *  - 'full': Perform complete analysis including API search and view hierarchy preprocessing
+ * @default 'fast'
+ */
+export type AnalysisMode = 'fast' | 'full';
+
 /**
  * Configuration options for the Copilot behavior.
  */
@@ -166,6 +174,12 @@ export interface CopilotOptions {
      * @default 'full'
      */
     cacheMode?: CacheMode;
+
+    /**
+     * The analysis mode to use.
+     * @default 'fast'
+     */
+    analysisMode?: AnalysisMode;
 }
 /**
  * Configuration options for Copilot.
diff --git a/src/utils/APIFormatter.test.ts b/src/utils/APIFormatter.test.ts
new file mode 100644
index 0000000..3c43e4d
--- /dev/null
+++ b/src/utils/APIFormatter.test.ts
@@ -0,0 +1,101 @@
+import {APIFormatter} from '@/utils/APIFormatter';
+import {TestingFrameworkAPICatalog} from '@/types';
+
+describe('APIFormatter', () => {
+    const mockAPI: TestingFrameworkAPICatalog = {
+        context: {},
+        name: 'Test Framework',
+        description: 'A testing framework for testing purposes',
+        categories: [
+            {
+                title: 'Actions',
+                items: [
+                    {
+                        signature: 'tap(element: Element)',
+                        description: 'Taps on the specified element.',
+                        example: 'await element(by.id("button")).tap();',
+                        guidelines: ['Ensure the element is tappable before using this method.']
+                    },
+                    {
+                        signature: 'typeText(element: Element, text: string)',
+                        description: 'Types the specified text into the element.',
+                        example: 'await element(by.id("input")).typeText("Hello, World!");',
+                        guidelines: ['Use this method only on text input elements.']
+                    }
+                ]
+            },
+            {
+                title: 'Assertions',
+                items: [
+                    {
+                        signature: 'toBeVisible()',
+                        description: 'Asserts that the element is visible on the screen.',
+                        example: 'await expect(element(by.id("title"))).toBeVisible();',
+                        guidelines: ['Consider scroll position when using this assertion.']
+                    }
+                ]
+            },
+            {
+                title: 'Matchers',
+                items: [
+                    {
+                        signature: 'by.id(id: string)',
+                        description: 'Matches elements by their ID attribute.',
+                        example: 'element(by.id("uniqueId"))',
+                        guidelines: ['Use unique IDs for elements to avoid conflicts.']
+                    }
+                ]
+            }
+        ]
+    };
+
+    let apiFormatter: APIFormatter;
+
+    beforeEach(() => {
+        apiFormatter = new APIFormatter(mockAPI);
+    });
+
+    describe('formatAPIMethod', () => {
+        it('should format method with guidelines', () => {
+            const method = mockAPI.categories[0].items[0];
+            expect(apiFormatter.formatAPIMethod(method)).toMatchSnapshot();
+        });
+
+        it('should format method without guidelines', () => {
+            const method = {
+                ...mockAPI.categories[0].items[0],
+                guidelines: undefined
+            };
+            expect(apiFormatter.formatAPIMethod(method)).toMatchSnapshot();
+        });
+    });
+
+    describe('formatAPICategory', () => {
+        it('should format category with all its methods', () => {
+            const category = mockAPI.categories[0];
+            expect(apiFormatter.formatAPICategory(category)).toMatchSnapshot();
+        });
+
+        it('should format empty category', () => {
+            const category = {
+                title: 'Empty Category',
+                items: []
+            };
+            expect(apiFormatter.formatAPICategory(category)).toMatchSnapshot();
+        });
+    });
+
+    describe('formatAPIInfo', () => {
+        it('should format all methods grouped by categories', () => {
+            expect(apiFormatter.formatAPIInfo()).toMatchSnapshot();
+        });
+
+        it('should format empty API catalog', () => {
+            const emptyFormatter = new APIFormatter({
+                context: {},
+                categories: []
+            });
+            expect(emptyFormatter.formatAPIInfo()).toMatchSnapshot();
+        });
+    });
+});
diff --git a/src/utils/APIFormatter.ts b/src/utils/APIFormatter.ts
new file mode 100644
index 0000000..e895783
--- /dev/null
+++ b/src/utils/APIFormatter.ts
@@ -0,0 +1,58 @@
+import {
+    TestingFrameworkAPICatalog,
+    TestingFrameworkAPICatalogCategory,
+    TestingFrameworkAPICatalogItem
+} from '@/types';
+
+export class APIFormatter {
+    constructor(private apiCatalog: TestingFrameworkAPICatalog) {}
+
+    /**
+     * Formats API method
+     */
+    formatAPIMethod(method: TestingFrameworkAPICatalogItem): string {
+        const methodInfo = [
+            `#### ${method.signature}`,
+            "",
+            method.description,
+            "",
+            "##### Example",
+            "",
+            "```",
+            method.example,
+            "```",
+            ""
+        ];
+
+        if (method.guidelines && method.guidelines.length > 0) {
+            methodInfo.push(
+                "##### Guidelines",
+                "",
+                ...method.guidelines.map(g => `- ${g}`),
+                ""
+            );
+        }
+
+        return methodInfo.join('\n');
+    }
+
+    /**
+     * Formats API category with its methods
+     */
+    formatAPICategory(category: TestingFrameworkAPICatalogCategory): string {
+        return [
+            `### ${category.title}`,
+            "",
+            ...category.items.map(item => this.formatAPIMethod(item))
+        ].join('\n');
+    }
+
+    /**
+     * Formats all API methods grouped by categories
+     */
+    formatAPIInfo(): string {
+        return this.apiCatalog.categories
+            .map(category => this.formatAPICategory(category))
+            .join('\n');
+    }
+}
diff --git a/src/utils/CopilotAPISearchPromptCreator.test.ts b/src/utils/CopilotAPISearchPromptCreator.test.ts
new file mode 100644
index 0000000..11da966
--- /dev/null
+++ b/src/utils/CopilotAPISearchPromptCreator.test.ts
@@ -0,0 +1,105 @@
+import {CopilotAPISearchPromptCreator} from '@/utils/CopilotAPISearchPromptCreator';
+import {TestingFrameworkAPICatalog} from '@/types';
+
+describe('CopilotAPISearchPromptCreator', () => {
+    const mockAPI: TestingFrameworkAPICatalog = {
+        context: {},
+        name: 'Test Framework',
+        description: 'A testing framework for testing purposes',
+        categories: [
+            {
+                title: 'Actions',
+                items: [
+                    {
+                        signature: 'tap(element: Element)',
+                        description: 'Taps on the specified element.',
+                        example: 'await element(by.id("button")).tap();',
+                        guidelines: ['Ensure the element is tappable before using this method.']
+                    },
+                    {
+                        signature: 'typeText(element: Element, text: string)',
+                        description: 'Types the specified text into the element.',
+                        example: 'await element(by.id("input")).typeText("Hello, World!");',
+                        guidelines: ['Use this method only on text input elements.']
+                    }
+                ]
+            },
+            {
+                title: 'Assertions',
+                items: [
+                    {
+                        signature: 'toBeVisible()',
+                        description: 'Asserts that the element is visible on the screen.',
+                        example: 'await expect(element(by.id("title"))).toBeVisible();',
+                        guidelines: ['Consider scroll position when using this assertion.']
+                    }
+                ]
+            },
+            {
+                title: 'Matchers',
+                items: [
+                    {
+                        signature: 'by.id(id: string)',
+                        description: 'Matches elements by their ID attribute.',
+                        example: 'element(by.id("uniqueId"))',
+                        guidelines: ['Use unique IDs for elements to avoid conflicts.']
+                    }
+                ]
+            }
+        ]
+    };
+
+    let promptCreator: CopilotAPISearchPromptCreator;
+
+    beforeEach(() => {
+        promptCreator = new CopilotAPISearchPromptCreator(mockAPI);
+    });
+
+    it('should create the prompt properly', () => {
+        const step = 'tap the login button';
+        const prompt = promptCreator.createPrompt(step);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should include view analysis result when provided', () => {
+        const step = 'tap the login button';
+        const viewAnalysisResult = 'Basic Element Description:\nA button in a navigation bar\n\nElement Location Analysis:\n...';
+        const prompt = promptCreator.createPrompt(step, viewAnalysisResult);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should handle empty API catalog', () => {
+        const emptyAPICreator = new CopilotAPISearchPromptCreator({
+            context: {},
+            categories: []
+        });
+        const step = 'tap the login button';
+        const prompt = emptyAPICreator.createPrompt(step);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should handle complex multi-step intent', () => {
+        const step = 'scroll to the bottom of the list, find the last item with title "Complete", and verify it is visible';
+        const prompt = promptCreator.createPrompt(step);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should handle special characters in step', () => {
+        const step = 'verify text contains "Hello & goodbye" with <special> chars';
+        const prompt = promptCreator.createPrompt(step);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should handle empty view analysis result', () => {
+        const step = 'tap the login button';
+        const viewAnalysisResult = '';
+        const prompt = promptCreator.createPrompt(step, viewAnalysisResult);
+
+        expect(prompt).toMatchSnapshot();
+    });
+});
diff --git a/src/utils/CopilotAPISearchPromptCreator.ts b/src/utils/CopilotAPISearchPromptCreator.ts
new file mode 100644
index 0000000..2480d5e
--- /dev/null
+++ b/src/utils/CopilotAPISearchPromptCreator.ts
@@ -0,0 +1,78 @@
+import {TestingFrameworkAPICatalog} from '@/types';
+import {APIFormatter} from '@/utils/APIFormatter';
+
+export class CopilotAPISearchPromptCreator {
+    private apiFormatter: APIFormatter;
+
+    constructor(private apiCatalog: TestingFrameworkAPICatalog) {
+        this.apiFormatter = new APIFormatter(apiCatalog);
+    }
+
+    createPrompt(step: string, viewAnalysisResult?: string): string {
+        return [
+            "# API Method Search",
+            "",
+            "## Task Description",
+            "",
+            `Find API methods and categories that semantically match this task: "${step}"`,
+            "",
+            ...(viewAnalysisResult ? [
+                "## View Analysis Context",
+                "",
+                viewAnalysisResult,
+                ""
+            ] : []),
+            "## Search Context",
+            "The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.",
+            "",
+            "## Available API Methods",
+            "",
+            this.apiFormatter.formatAPIInfo(),
+            "",
+            "## Instructions",
+            "",
+            "1. Analyze the semantic patterns in the task:",
+            "   - Key terms and actions",
+            "   - Object and state descriptions",
+            "   - Expected behaviors and outcomes",
+            "",
+            "2. Review semantic matches found:",
+            "   - Evaluate similarity scores",
+            "   - Consider partial matches",
+            "   - Note contextual relevance",
+            "",
+            "3. For each semantic match, assess:",
+            "   - Match confidence level",
+            "   - Contextual applicability",
+            "   - Potential limitations",
+            "",
+            "Please provide your response in the following format:",
+            "",
+            "```",
+            "Semantic Category Matches:",
+            "1. [Category Name]",
+            "   - Match Confidence: [High/Medium/Low - Why this category semantically matches]",
+            "   - Context Notes: [Important contextual considerations]",
+            "   - Limitations: [Where the semantic match might not translate to practical use]",
+            "",
+            "Semantic API Matches:",
+            "1. methodName(params)",
+            "   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]",
+            "   - Context Notes: [How the semantic match relates to actual usage]",
+            "   - Limitations: [Potential gaps between semantic match and practical application]",
+            "```",
+            "",
+            "Search Evaluation:",
+            "- Consider that semantic matches may not be optimal solutions",
+            "- Evaluate practical applicability beyond semantic similarity",
+            "- Look for gaps between semantic matches and actual requirements",
+            "- Consider alternative approaches if semantic matches are weak",
+            "",
+            "Additional Context:",
+            "- Note the confidence level of semantic matches",
+            "- Highlight where semantic similarity might be misleading",
+            "- Suggest verification steps before accepting matches",
+            "",
+        ].join('\n');
+    }
+}
diff --git a/src/utils/PromptCreator.test.ts b/src/utils/PromptCreator.test.ts
index a2c0dab..84a8150 100644
--- a/src/utils/PromptCreator.test.ts
+++ b/src/utils/PromptCreator.test.ts
@@ -1,9 +1,9 @@
-import {PromptCreator} from './PromptCreator';
+import {PromptCreator} from '@/utils/PromptCreator';
 import {
     PreviousStep,
     TestingFrameworkAPICatalog
 } from "@/types";
-import {bazCategory, barCategory2, promptCreatorConstructorMockAPI} from "../test-utils/APICatalogTestUtils";
+import {bazCategory, barCategory2, promptCreatorConstructorMockAPI} from "@/test-utils/APICatalogTestUtils";
 
 const mockAPI: TestingFrameworkAPICatalog = {
     context: {},
@@ -108,6 +108,38 @@ describe('PromptCreator', () => {
         expect(prompt).toMatchSnapshot();
     });
 
+    it('should include API search results when provided', () => {
+        const intent = 'tap button';
+        const viewHierarchy = '<View><Button testID="submit" title="Submit" /></View>';
+        const apiSearchResults = [
+            'Semantic Category Matches:',
+            '1. Actions',
+            '   - Match Confidence: High - Contains tap-related actions',
+            '   - Context Notes: Direct interaction with buttons',
+            '',
+            'Semantic API Matches:',
+            '1. tap(element: Element)',
+            '   - Match Confidence: High - Direct semantic match for tapping',
+            '   - Context Notes: Primary method for button interaction',
+            '2. by.id(id: string)',
+            '   - Match Confidence: Medium - Required for element selection',
+            '   - Context Notes: Used to locate the target button'
+        ].join('\n');
+
+        const prompt = promptCreator.createPrompt(intent, viewHierarchy, false, [], apiSearchResults);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should not include API search results section when not provided', () => {
+        const intent = 'tap button';
+        const viewHierarchy = '<View><Button testID="submit" title="Submit" /></View>';
+
+        const prompt = promptCreator.createPrompt(intent, viewHierarchy, false, []);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
     describe('extentAPICategories', () => {
         const intent = 'expect button to be visible';
         const viewHierarchy = '<View><Button testID="submit" title="Submit" /></View>';
diff --git a/src/utils/PromptCreator.ts b/src/utils/PromptCreator.ts
index e24d461..762c0ea 100644
--- a/src/utils/PromptCreator.ts
+++ b/src/utils/PromptCreator.ts
@@ -4,10 +4,14 @@ import {
     TestingFrameworkAPICatalogCategory,
     TestingFrameworkAPICatalogItem
 } from "@/types";
+import {APIFormatter} from '@/utils/APIFormatter';
 
 export class PromptCreator {
-    constructor(private apiCatalog: TestingFrameworkAPICatalog) {
+    private apiFormatter: APIFormatter;
+
+    constructor(public readonly apiCatalog: TestingFrameworkAPICatalog) {
         this.apiCatalog.categories = this.mergeCategories(this.apiCatalog.categories);
+        this.apiFormatter = new APIFormatter(this.apiCatalog);
     }
 
     extendAPICategories(
@@ -37,12 +41,19 @@ export class PromptCreator {
         intent: string,
         viewHierarchy: string,
         isSnapshotImageAttached: boolean,
-        previousSteps: PreviousStep[]
+        previousSteps: PreviousStep[],
+        apiSearchResults?: string
     ): string {
         return [
             this.createBasePrompt(),
             this.createContext(intent, viewHierarchy, isSnapshotImageAttached, previousSteps),
             this.createAPIInfo(),
+            ...(apiSearchResults ? [
+                "## Semantic Matches from API Search",
+                "",
+                apiSearchResults,
+                ""
+            ] : []),
             this.createInstructions(intent, isSnapshotImageAttached)
         ]
             .flat()
@@ -61,12 +72,12 @@ export class PromptCreator {
         if (this.apiCatalog.name || this.apiCatalog.description) {
             basePrompt.push("## Testing Framework");
             basePrompt.push("");
-            
+
             if (this.apiCatalog.name) {
                 basePrompt.push(`Framework: ${this.apiCatalog.name}`);
                 basePrompt.push("");
             }
-            
+
             if (this.apiCatalog.description) {
                 basePrompt.push(`Description: ${this.apiCatalog.description}`);
                 basePrompt.push("");
@@ -137,48 +148,11 @@ export class PromptCreator {
     private createAPIInfo(): string[] {
         return [
             "## Available Testing Framework API",
-            ""
-        ].concat(
-            this.apiCatalog.categories
-                .map((category) => this.formatAPICategory(category))
-                .flat()
-        );
-    }
-
-    private formatAPICategory(category: TestingFrameworkAPICatalogCategory): string[] {
-        return [
-            `### ${category.title}`,
             "",
-            ...category.items.map((item) => this.formatAPIMethod(item)).flat()
+            this.apiFormatter.formatAPIInfo()
         ];
     }
 
-    private formatAPIMethod(method: TestingFrameworkAPICatalogItem): string[] {
-        const methodInfo = [
-            `#### ${method.signature}`,
-            "",
-            method.description,
-            "",
-            "##### Example",
-            "",
-            "```",
-            method.example,
-            "```",
-            ""
-        ];
-
-        if (method.guidelines && method.guidelines.length > 0) {
-            methodInfo.push(
-                "##### Guidelines",
-                "",
-                ...method.guidelines.map((guideline) => `- ${guideline}`),
-                ""
-            );
-        }
-
-        return methodInfo;
-    }
-
     private createInstructions(intent: string, isSnapshotImageAttached: boolean): string[] {
         return [
             "## Instructions",
diff --git a/src/utils/ViewAnalysisPromptCreator.test.ts b/src/utils/ViewAnalysisPromptCreator.test.ts
new file mode 100644
index 0000000..eeb9bf7
--- /dev/null
+++ b/src/utils/ViewAnalysisPromptCreator.test.ts
@@ -0,0 +1,54 @@
+import {ViewAnalysisPromptCreator} from '@/utils/ViewAnalysisPromptCreator';
+import {TestingFrameworkAPICatalog} from '@/types';
+
+describe('ViewAnalysisPromptCreator', () => {
+    const mockAPI: TestingFrameworkAPICatalog = {
+        context: {},
+        name: 'Test Framework',
+        description: 'A testing framework for testing purposes',
+        categories: []
+    };
+
+    let analyzer: ViewAnalysisPromptCreator;
+
+    beforeEach(() => {
+        analyzer = new ViewAnalysisPromptCreator(mockAPI);
+    });
+
+    it('should create the prompt properly', () => {
+        const step = 'tap the login button';
+        const viewHierarchy = '<View><Button testID="login" title="Login" /></View>';
+        const prompt = analyzer.createPrompt(step, viewHierarchy);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should include previous steps in the prompt when provided', () => {
+        const step = 'tap the login button';
+        const viewHierarchy = '<View><Button testID="login" title="Login" /></View>';
+        const previousSteps = [
+            {
+                step: 'navigate to login screen',
+                code: 'await element(by.id("login")).tap();',
+                result: 'success'
+            },
+            {
+                step: 'enter username',
+                code: 'await element(by.id("username")).typeText("john_doe");',
+                result: 'john doe'
+            }
+        ];
+
+        const prompt = analyzer.createPrompt(step, viewHierarchy, previousSteps);
+
+        expect(prompt).toMatchSnapshot();
+    });
+
+    it('should handle empty view hierarchy', () => {
+        const step = 'tap the login button';
+        const viewHierarchy = '';
+        const prompt = analyzer.createPrompt(step, viewHierarchy);
+
+        expect(prompt).toMatchSnapshot();
+    });
+});
diff --git a/src/utils/ViewAnalysisPromptCreator.ts b/src/utils/ViewAnalysisPromptCreator.ts
new file mode 100644
index 0000000..dff660d
--- /dev/null
+++ b/src/utils/ViewAnalysisPromptCreator.ts
@@ -0,0 +1,76 @@
+import {TestingFrameworkAPICatalog, PreviousStep} from '../types';
+
+export class ViewAnalysisPromptCreator {
+    constructor(private apiCatalog: TestingFrameworkAPICatalog) {}
+
+    createPrompt(step: string, viewHierarchy: string, previousSteps: PreviousStep[] = []): string {
+        return [
+            "# View Hierarchy Analysis",
+            "",
+            "## Task Description",
+            "",
+            `Analyze the view hierarchy to identify the location and context of elements relevant to this task: "${step}"`,
+            "",
+            "## View Hierarchy",
+            "```",
+            viewHierarchy,
+            "```",
+            "",
+            ...(previousSteps.length > 0 ? [
+                "## Previous Steps Context",
+                "",
+                ...previousSteps.map((previousStep, index) => [
+                    `### Step ${index + 1}`,
+                    `- Intent: "${previousStep.step}"`,
+                    `- Result: ${previousStep.result}`,
+                    ""
+                ]).flat()
+            ] : []),
+            "## Instructions",
+            "",
+            "1. Analyze the view hierarchy structure:",
+            "   - Identify the target element's location",
+            "   - Understand the surrounding layout context",
+            "   - Note any parent-child relationships",
+            "",
+            "2. Evaluate element accessibility:",
+            "   - Check if element is likely to be visible",
+            "   - Identify potential scroll requirements",
+            "   - Note any overlapping elements",
+            "",
+            "3. Describe the layout context:",
+            "   - Parent container type (e.g., list, grid, navigation bar)",
+            "   - Relative positioning (e.g., top of screen, within a card)",
+            "   - Relationship to other UI elements",
+            "",
+            "Please provide your response in the following format:",
+            "",
+            "```",
+            "Basic Element Description:",
+            "A concise one-line description of what is being targeted (e.g., 'A button in a navigation bar', 'A text input in a form', 'The entire screen', 'A cell in a list')",
+            "",
+            "Element Location Analysis:",
+            "1. Target Element Context",
+            "   - Element Type: [The type of UI element being targeted]",
+            "   - Container: [The parent container/view type]",
+            "   - Position: [Where in the view hierarchy/screen the element is located]",
+            "",
+            "2. Accessibility Considerations",
+            "   - Visibility: [Likely visibility status and any potential issues]",
+            "   - Scroll Requirements: [Whether scrolling might be needed]",
+            "   - Interaction Constraints: [Any potential barriers to interaction]",
+            "",
+            "3. Layout Structure",
+            "   - Parent Hierarchy: [Description of the view hierarchy path to the element]",
+            "   - Sibling Elements: [Related elements that might affect interaction]",
+            "   - Screen Region: [General region of the screen where the element is located]",
+            "```",
+            "",
+            "Additional Notes:",
+            "- Focus on structural understanding rather than implementation details",
+            "- Consider how the element's location affects test reliability",
+            "- Note any potential challenges in locating or interacting with the element",
+            "",
+        ].join('\n');
+    }
+} 
diff --git a/src/utils/__snapshots__/APIFormatter.test.ts.snap b/src/utils/__snapshots__/APIFormatter.test.ts.snap
new file mode 100644
index 0000000..c7007d2
--- /dev/null
+++ b/src/utils/__snapshots__/APIFormatter.test.ts.snap
@@ -0,0 +1,136 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`APIFormatter formatAPICategory should format category with all its methods 1`] = `
+"### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+"
+`;
+
+exports[`APIFormatter formatAPICategory should format empty category 1`] = `
+"### Empty Category
+"
+`;
+
+exports[`APIFormatter formatAPIInfo should format all methods grouped by categories 1`] = `
+"### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+"
+`;
+
+exports[`APIFormatter formatAPIInfo should format empty API catalog 1`] = `""`;
+
+exports[`APIFormatter formatAPIMethod should format method with guidelines 1`] = `
+"#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+"
+`;
+
+exports[`APIFormatter formatAPIMethod should format method without guidelines 1`] = `
+"#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+"
+`;
diff --git a/src/utils/__snapshots__/CopilotAPISearchPromptCreator.test.ts.snap b/src/utils/__snapshots__/CopilotAPISearchPromptCreator.test.ts.snap
new file mode 100644
index 0000000..aff5a5f
--- /dev/null
+++ b/src/utils/__snapshots__/CopilotAPISearchPromptCreator.test.ts.snap
@@ -0,0 +1,674 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`CopilotAPISearchPromptCreator should create the prompt properly 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "tap the login button"
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
+
+exports[`CopilotAPISearchPromptCreator should handle complex multi-step intent 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "scroll to the bottom of the list, find the last item with title "Complete", and verify it is visible"
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
+
+exports[`CopilotAPISearchPromptCreator should handle empty API catalog 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "tap the login button"
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
+
+exports[`CopilotAPISearchPromptCreator should handle empty view analysis result 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "tap the login button"
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
+
+exports[`CopilotAPISearchPromptCreator should handle special characters in step 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "verify text contains "Hello & goodbye" with <special> chars"
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
+
+exports[`CopilotAPISearchPromptCreator should include view analysis result when provided 1`] = `
+"# API Method Search
+
+## Task Description
+
+Find API methods and categories that semantically match this task: "tap the login button"
+
+## View Analysis Context
+
+Basic Element Description:
+A button in a navigation bar
+
+Element Location Analysis:
+...
+
+## Search Context
+The following results are based on semantic similarity to your task. They represent potential matches that should be carefully evaluated, not necessarily the optimal or recommended solutions.
+
+## Available API Methods
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts.
+
+
+## Instructions
+
+1. Analyze the semantic patterns in the task:
+   - Key terms and actions
+   - Object and state descriptions
+   - Expected behaviors and outcomes
+
+2. Review semantic matches found:
+   - Evaluate similarity scores
+   - Consider partial matches
+   - Note contextual relevance
+
+3. For each semantic match, assess:
+   - Match confidence level
+   - Contextual applicability
+   - Potential limitations
+
+Please provide your response in the following format:
+
+\`\`\`
+Semantic Category Matches:
+1. [Category Name]
+   - Match Confidence: [High/Medium/Low - Why this category semantically matches]
+   - Context Notes: [Important contextual considerations]
+   - Limitations: [Where the semantic match might not translate to practical use]
+
+Semantic API Matches:
+1. methodName(params)
+   - Match Confidence: [High/Medium/Low - Explain the semantic similarity]
+   - Context Notes: [How the semantic match relates to actual usage]
+   - Limitations: [Potential gaps between semantic match and practical application]
+\`\`\`
+
+Search Evaluation:
+- Consider that semantic matches may not be optimal solutions
+- Evaluate practical applicability beyond semantic similarity
+- Look for gaps between semantic matches and actual requirements
+- Consider alternative approaches if semantic matches are weak
+
+Additional Context:
+- Note the confidence level of semantic matches
+- Highlight where semantic similarity might be misleading
+- Suggest verification steps before accepting matches
+"
+`;
diff --git a/src/utils/__snapshots__/PromptCreator.test.ts.snap b/src/utils/__snapshots__/PromptCreator.test.ts.snap
index 3172f88..349210a 100644
--- a/src/utils/__snapshots__/PromptCreator.test.ts.snap
+++ b/src/utils/__snapshots__/PromptCreator.test.ts.snap
@@ -659,6 +659,135 @@ throw new Error("Unable to find the 'Submit' button element in the current conte
 Please provide your response below:"
 `;
 
+exports[`PromptCreator should include API search results when provided 1`] = `
+"# Test Code Generation
+
+You are an AI assistant tasked with generating test code for an application using the provided UI testing framework API.
+Please generate the minimal executable code to perform the desired intent based on the given information and context.
+
+## Context
+
+### Intent to perform
+
+Generate the minimal executable code to perform the following intent: "tap button"
+
+### View hierarchy
+
+\`\`\`
+<View><Button testID="submit" title="Submit" /></View>
+\`\`\`
+
+### Snapshot image
+
+No snapshot image is attached for this intent.
+
+## Available Testing Framework API
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts, combine with atIndex() if necessary.
+
+## Semantic Matches from API Search
+
+Semantic Category Matches:
+1. Actions
+   - Match Confidence: High - Contains tap-related actions
+   - Context Notes: Direct interaction with buttons
+
+Semantic API Matches:
+1. tap(element: Element)
+   - Match Confidence: High - Direct semantic match for tapping
+   - Context Notes: Primary method for button interaction
+2. by.id(id: string)
+   - Match Confidence: Medium - Required for element selection
+   - Context Notes: Used to locate the target button
+
+## Instructions
+
+Your task is to generate the minimal executable code to perform the following intent: "tap button"
+
+Please follow these steps carefully:
+
+1. Analyze the provided intent and the view hierarchy to understand the required action.
+2. Generate the minimal executable code required to perform the intent using the available API.
+3. If you cannot generate the relevant code due to ambiguity or invalid intent, return code that throws an informative error explaining the problem in one sentence.
+4. Each step must be completely independent - do not rely on any variables or assignments from previous steps. Even if a variable was declared or assigned in a previous step, you must redeclare and reassign it in your current step.
+5. Use the provided framework APIs as much as possible - prefer using the documented API methods over creating custom implementations.
+6. Wrap the generated code with backticks, without any additional formatting.
+7. Do not provide any additional code beyond the minimal executable code required to perform the intent.
+
+### Verify the prompt
+
+Before generating the code, please review the provided context and instructions to ensure they are clear and unambiguous. If you encounter any issues or have questions, please throw an informative error explaining the problem.
+
+### Examples
+
+#### Example of throwing an informative error:
+\`\`\`typescript
+throw new Error("Unable to find the 'Submit' button element in the current context.");
+\`\`\`
+
+Please provide your response below:"
+`;
+
 exports[`PromptCreator should include previous intents in the context 1`] = `
 "# Test Code Generation
 
@@ -700,6 +829,120 @@ await element(by.id("username")).typeText("john_doe");
 - Result: john doe
 
 
+## Available Testing Framework API
+
+### Actions
+
+#### tap(element: Element)
+
+Taps on the specified element.
+
+##### Example
+
+\`\`\`
+await element(by.id("button")).tap();
+\`\`\`
+
+##### Guidelines
+
+- Ensure the element is tappable before using this method.
+
+#### typeText(element: Element, text: string)
+
+Types the specified text into the element.
+
+##### Example
+
+\`\`\`
+await element(by.id("input")).typeText("Hello, World!");
+\`\`\`
+
+##### Guidelines
+
+- Use this method only on text input elements.
+
+### Assertions
+
+#### toBeVisible()
+
+Asserts that the element is visible on the screen.
+
+##### Example
+
+\`\`\`
+await expect(element(by.id("title"))).toBeVisible();
+\`\`\`
+
+##### Guidelines
+
+- Consider scroll position when using this assertion.
+
+### Matchers
+
+#### by.id(id: string)
+
+Matches elements by their ID attribute.
+
+##### Example
+
+\`\`\`
+element(by.id("uniqueId"))
+\`\`\`
+
+##### Guidelines
+
+- Use unique IDs for elements to avoid conflicts, combine with atIndex() if necessary.
+
+## Instructions
+
+Your task is to generate the minimal executable code to perform the following intent: "tap button"
+
+Please follow these steps carefully:
+
+1. Analyze the provided intent and the view hierarchy to understand the required action.
+2. Generate the minimal executable code required to perform the intent using the available API.
+3. If you cannot generate the relevant code due to ambiguity or invalid intent, return code that throws an informative error explaining the problem in one sentence.
+4. Each step must be completely independent - do not rely on any variables or assignments from previous steps. Even if a variable was declared or assigned in a previous step, you must redeclare and reassign it in your current step.
+5. Use the provided framework APIs as much as possible - prefer using the documented API methods over creating custom implementations.
+6. Wrap the generated code with backticks, without any additional formatting.
+7. Do not provide any additional code beyond the minimal executable code required to perform the intent.
+
+### Verify the prompt
+
+Before generating the code, please review the provided context and instructions to ensure they are clear and unambiguous. If you encounter any issues or have questions, please throw an informative error explaining the problem.
+
+### Examples
+
+#### Example of throwing an informative error:
+\`\`\`typescript
+throw new Error("Unable to find the 'Submit' button element in the current context.");
+\`\`\`
+
+Please provide your response below:"
+`;
+
+exports[`PromptCreator should not include API search results section when not provided 1`] = `
+"# Test Code Generation
+
+You are an AI assistant tasked with generating test code for an application using the provided UI testing framework API.
+Please generate the minimal executable code to perform the desired intent based on the given information and context.
+
+## Context
+
+### Intent to perform
+
+Generate the minimal executable code to perform the following intent: "tap button"
+
+### View hierarchy
+
+\`\`\`
+<View><Button testID="submit" title="Submit" /></View>
+\`\`\`
+
+### Snapshot image
+
+No snapshot image is attached for this intent.
+
 ## Available Testing Framework API
 
 ### Actions
diff --git a/src/utils/__snapshots__/ViewAnalysisPromptCreator.test.ts.snap b/src/utils/__snapshots__/ViewAnalysisPromptCreator.test.ts.snap
new file mode 100644
index 0000000..654e411
--- /dev/null
+++ b/src/utils/__snapshots__/ViewAnalysisPromptCreator.test.ts.snap
@@ -0,0 +1,188 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ViewAnalysisPromptCreator should create the prompt properly 1`] = `
+"# View Hierarchy Analysis
+
+## Task Description
+
+Analyze the view hierarchy to identify the location and context of elements relevant to this task: "tap the login button"
+
+## View Hierarchy
+\`\`\`
+<View><Button testID="login" title="Login" /></View>
+\`\`\`
+
+## Instructions
+
+1. Analyze the view hierarchy structure:
+   - Identify the target element's location
+   - Understand the surrounding layout context
+   - Note any parent-child relationships
+
+2. Evaluate element accessibility:
+   - Check if element is likely to be visible
+   - Identify potential scroll requirements
+   - Note any overlapping elements
+
+3. Describe the layout context:
+   - Parent container type (e.g., list, grid, navigation bar)
+   - Relative positioning (e.g., top of screen, within a card)
+   - Relationship to other UI elements
+
+Please provide your response in the following format:
+
+\`\`\`
+Basic Element Description:
+A concise one-line description of what is being targeted (e.g., 'A button in a navigation bar', 'A text input in a form', 'The entire screen', 'A cell in a list')
+
+Element Location Analysis:
+1. Target Element Context
+   - Element Type: [The type of UI element being targeted]
+   - Container: [The parent container/view type]
+   - Position: [Where in the view hierarchy/screen the element is located]
+
+2. Accessibility Considerations
+   - Visibility: [Likely visibility status and any potential issues]
+   - Scroll Requirements: [Whether scrolling might be needed]
+   - Interaction Constraints: [Any potential barriers to interaction]
+
+3. Layout Structure
+   - Parent Hierarchy: [Description of the view hierarchy path to the element]
+   - Sibling Elements: [Related elements that might affect interaction]
+   - Screen Region: [General region of the screen where the element is located]
+\`\`\`
+
+Additional Notes:
+- Focus on structural understanding rather than implementation details
+- Consider how the element's location affects test reliability
+- Note any potential challenges in locating or interacting with the element
+"
+`;
+
+exports[`ViewAnalysisPromptCreator should handle empty view hierarchy 1`] = `
+"# View Hierarchy Analysis
+
+## Task Description
+
+Analyze the view hierarchy to identify the location and context of elements relevant to this task: "tap the login button"
+
+## View Hierarchy
+\`\`\`
+
+\`\`\`
+
+## Instructions
+
+1. Analyze the view hierarchy structure:
+   - Identify the target element's location
+   - Understand the surrounding layout context
+   - Note any parent-child relationships
+
+2. Evaluate element accessibility:
+   - Check if element is likely to be visible
+   - Identify potential scroll requirements
+   - Note any overlapping elements
+
+3. Describe the layout context:
+   - Parent container type (e.g., list, grid, navigation bar)
+   - Relative positioning (e.g., top of screen, within a card)
+   - Relationship to other UI elements
+
+Please provide your response in the following format:
+
+\`\`\`
+Basic Element Description:
+A concise one-line description of what is being targeted (e.g., 'A button in a navigation bar', 'A text input in a form', 'The entire screen', 'A cell in a list')
+
+Element Location Analysis:
+1. Target Element Context
+   - Element Type: [The type of UI element being targeted]
+   - Container: [The parent container/view type]
+   - Position: [Where in the view hierarchy/screen the element is located]
+
+2. Accessibility Considerations
+   - Visibility: [Likely visibility status and any potential issues]
+   - Scroll Requirements: [Whether scrolling might be needed]
+   - Interaction Constraints: [Any potential barriers to interaction]
+
+3. Layout Structure
+   - Parent Hierarchy: [Description of the view hierarchy path to the element]
+   - Sibling Elements: [Related elements that might affect interaction]
+   - Screen Region: [General region of the screen where the element is located]
+\`\`\`
+
+Additional Notes:
+- Focus on structural understanding rather than implementation details
+- Consider how the element's location affects test reliability
+- Note any potential challenges in locating or interacting with the element
+"
+`;
+
+exports[`ViewAnalysisPromptCreator should include previous steps in the prompt when provided 1`] = `
+"# View Hierarchy Analysis
+
+## Task Description
+
+Analyze the view hierarchy to identify the location and context of elements relevant to this task: "tap the login button"
+
+## View Hierarchy
+\`\`\`
+<View><Button testID="login" title="Login" /></View>
+\`\`\`
+
+## Previous Steps Context
+
+### Step 1
+- Intent: "navigate to login screen"
+- Result: success
+
+### Step 2
+- Intent: "enter username"
+- Result: john doe
+
+## Instructions
+
+1. Analyze the view hierarchy structure:
+   - Identify the target element's location
+   - Understand the surrounding layout context
+   - Note any parent-child relationships
+
+2. Evaluate element accessibility:
+   - Check if element is likely to be visible
+   - Identify potential scroll requirements
+   - Note any overlapping elements
+
+3. Describe the layout context:
+   - Parent container type (e.g., list, grid, navigation bar)
+   - Relative positioning (e.g., top of screen, within a card)
+   - Relationship to other UI elements
+
+Please provide your response in the following format:
+
+\`\`\`
+Basic Element Description:
+A concise one-line description of what is being targeted (e.g., 'A button in a navigation bar', 'A text input in a form', 'The entire screen', 'A cell in a list')
+
+Element Location Analysis:
+1. Target Element Context
+   - Element Type: [The type of UI element being targeted]
+   - Container: [The parent container/view type]
+   - Position: [Where in the view hierarchy/screen the element is located]
+
+2. Accessibility Considerations
+   - Visibility: [Likely visibility status and any potential issues]
+   - Scroll Requirements: [Whether scrolling might be needed]
+   - Interaction Constraints: [Any potential barriers to interaction]
+
+3. Layout Structure
+   - Parent Hierarchy: [Description of the view hierarchy path to the element]
+   - Sibling Elements: [Related elements that might affect interaction]
+   - Screen Region: [General region of the screen where the element is located]
+\`\`\`
+
+Additional Notes:
+- Focus on structural understanding rather than implementation details
+- Consider how the element's location affects test reliability
+- Note any potential challenges in locating or interacting with the element
+"
+`;
diff --git a/website/docs/API/basic-interface-overview.md b/website/docs/API/basic-interface-overview.md
index 4743f16..cf87964 100644
--- a/website/docs/API/basic-interface-overview.md
+++ b/website/docs/API/basic-interface-overview.md
@@ -167,6 +167,7 @@ interface Config {
 
 interface CopilotOptions {
   cacheMode?: 'full' | 'lightweight' | 'disabled';
+  analysisMode?: 'fast' | 'full';
 }
 ```
 
@@ -179,6 +180,14 @@ Default cache mode is `full`.
 - **lightweight**: Cache is used but only based on steps (without screen state)
 - **disabled**: No caching is used
 
+#### Analysis Modes
+
+Analysis mode determines how the Copilot analyzes each step before generating code.
+Default analysis mode is `fast`.
+
+- **fast**: Skip API search and view hierarchy analysis preprocessing (default)
+- **full**: Perform complete analysis including API search and view hierarchy preprocessing
+
 ### Framework Drivers
 
 :::note Available Drivers
diff --git a/website/docs/API/prompt-handler.md b/website/docs/API/prompt-handler.md
index b2de63b..848b13f 100644
--- a/website/docs/API/prompt-handler.md
+++ b/website/docs/API/prompt-handler.md
@@ -24,7 +24,7 @@ The `PromptHandler` interface includes the following methods:
 - **`runPrompt`**: Sends a prompt to the AI service and returns the generated response.
 - **`isSnapshotImageSupported`**: Checks if the AI service supports snapshot images to provide additional context.
 
-Here’s an example of the `PromptHandler` interface:
+Here’s the `PromptHandler` interface:
 
 ```typescript
 /**
@@ -46,71 +46,5 @@ export interface PromptHandler {
 }
 ```
 
-### Example: Implementing the Prompt Handler for Sonnet
-
-```typescript
-const axios = require('axios');
-const fs = require('fs').promises;
-
-class PromptHandler {
-  // Upload an image to the AI service
-  async uploadImage(imagePath) {
-    const image = await fs.readFile(imagePath);
-
-    try {
-      const response = await axios.post('https://bo.wix.com/mobile-infra-ai-services/v1/image-upload', {
-        image,
-      });
-
-      const imageUrl = response.data.url;
-      if (!imageUrl) {
-        throw new Error('Cannot find uploaded URL, got response:', response.data);
-      }
-
-      return imageUrl;
-    } catch (error) {
-      console.error('Error while uploading image:', error);
-      throw error;
-    }
-  }
-
-  // Run the prompt and return the generated text
-  async runPrompt(prompt, image) {
-    if (!image) {
-      throw new Error('Image is required');
-    }
-
-    const imageUrl = await this.uploadImage(image);
-
-    try {
-      const response = await axios.post('https://bo.wix.com/mobile-infra-ai-services/v1/prompt', {
-        prompt,
-        model: 'SONNET_3_5',
-        ownershipTag: 'Detox OSS',
-        project: 'Detox OSS',
-        images: [imageUrl]
-      });
-
-      const generatedText = response.data.generatedTexts[0];
-      if (!generatedText) {
-        throw new Error('Failed to generate text, got response:', response.data);
-      }
-
-      return generatedText;
-    } catch (error) {
-      console.error('Error running prompt:', error);
-      throw error;
-    }
-  }
-
-  // Check if snapshot images are supported
-  isSnapshotImageSupported() {
-    return true;
-  }
-}
-
-module.exports = PromptHandler;
-```
-
 ## Open Tasks For Contributors
 If you're interested in contributing to Copilot by Detox and adding new prompt handlers or improving the existing ones, check out the open tasks on our [GitHub repository](https://github.com/wix-incubator/detox-copilot/issues).