diff --git a/ai-testing-tool.py b/ai-testing-tool.py
index 85011f7..299a45b 100644
--- a/ai-testing-tool.py
+++ b/ai-testing-tool.py
@@ -24,14 +24,14 @@ class PlatformDetector:
     @staticmethod
     def detect_platform(page_source):
         """Detect platform based on page source structure"""
-        if '<html' in page_source.lower() or '<!doctype html' in page_source.lower():
-            return 'web'
-        elif 'XCUIElementType' in page_source:
-            return 'ios'
-        elif 'android' in page_source.lower() or 'hierarchy' in page_source.lower():
-            return 'android'
+        if "<html" in page_source.lower() or "<!doctype html" in page_source.lower():
+            return "web"
+        elif "XCUIElementType" in page_source:
+            return "ios"
+        elif "android" in page_source.lower() or "hierarchy" in page_source.lower():
+            return "android"
         else:
-            return 'unknown'
+            return "unknown"
 
 
 def read_file_content(file_path):
@@ -57,19 +57,18 @@ def image_to_base64(image_path):
 
 
 def generate_next_action(
-        prompt, task, history_actions, page_source_file, page_screenshot,
-        platform
-        ):
+    prompt, task, history_actions, page_source_file, page_screenshot, platform
+):
     screenshot_base64 = image_to_base64(page_screenshot)
     page_source = read_file_content(page_source_file)
     history_actions_str = "\n".join(history_actions)
 
     # Platform-specific context
     platform_context = {
-        'ios': "iOS XML with XCUIElementType elements",
-        'android': "Android XML with android hierarchy",
-        'web': "HTML DOM structure"
-        }
+        "ios": "iOS XML with XCUIElementType elements",
+        "android": "Android XML with android hierarchy",
+        "web": "HTML DOM structure",
+    }
 
     # Prepare the prompt for Ollama with platform context
     full_prompt = f"""{prompt}
@@ -101,18 +100,16 @@ def generate_next_action(
         "prompt": full_prompt,
         "images": [screenshot_base64],
         "stream": False,
-        "options": {
-            "num_predict": 200
-            }
-        }
+        "options": {"num_predict": 200},
+    }
 
     try:
         response = requests.post(
             "http://172.30.91.194:11434/api/generate",
             json=payload,
             headers={"Content-Type": "application/json"},
-            timeout=300
-            )
+            timeout=300,
+        )
         response.raise_for_status()
 
         result = response.json()
@@ -129,22 +126,25 @@ def generate_next_action(
 
 def get_platform_specific_instructions(platform):
     """Return platform-specific instructions for the AI model"""
-    if platform == 'ios':
+    if platform == "ios":
         return """- Use iOS element types: XCUIElementTypeButton, XCUIElementTypeTextField, etc.
 - Use @name, @label, @value attributes for identification
 - Calculate bounds from x, y, width, height attributes: [x,y][x+width,y+height]
+- Use read action with XPath or bounds to capture text values
 - Example XPath: //XCUIElementTypeButton[@name='Info'][@enabled='true']"""
 
-    elif platform == 'android':
+    elif platform == "android":
         return """- Use Android element types and attributes
 - Use @text, @resource-id, @content-desc for identification
 - Use bounds attribute directly: bounds="[x1,y1][x2,y2]"
+- Use read action with XPath or bounds to capture text values
 - Example XPath: //*[@text='Settings'] or //*[@resource-id='com.app:id/button']"""
 
-    elif platform == 'web':
+    elif platform == "web":
         return """- Use standard HTML elements: button, input, div, span, etc.
 - Use id, class, name, text content for identification
 - Use CSS selectors or XPath for web elements
+- Use read action with XPath, CSS, or bounds to capture text values
 - Example XPath: //button[text()='Submit'] or //input[@id='username']
 - For bounds, use element.location and element.size from Selenium"""
 
@@ -153,53 +153,51 @@ def get_platform_specific_instructions(platform):
 
 def create_driver(appium_server, platform_config):
     """Create appropriate driver based on platform configuration"""
-    platform = platform_config.get('platform', '').lower()
+    platform = platform_config.get("platform", "").lower()
 
-    if platform == 'ios':
-        appium_server = f'http://{appium_server}/wd/hub'
+    if platform == "ios":
+        appium_server = f"http://{appium_server}/wd/hub"
         capabilities = {
             "appium:xcodeSigningId": "App Development",
             "appium:automationName": "XCUITest",
             "platformName": "iOS",
-            "appium:deviceName": platform_config.get('deviceName', 'iPhone'),
-            "appium:udid": platform_config.get('udid'),
-            "appium:bundleId": platform_config.get('bundleId'),
-            "appium:wdaLocalPort": platform_config.get('wdaLocalPort', '8100')
-            }
+            "appium:deviceName": platform_config.get("deviceName", "iPhone"),
+            "appium:udid": platform_config.get("udid"),
+            "appium:bundleId": platform_config.get("bundleId"),
+            "appium:wdaLocalPort": platform_config.get("wdaLocalPort", "8100"),
+        }
         return appium_webdriver.Remote(
-            appium_server,
-            options=AppiumOptions().load_capabilities(capabilities)
-            )
+            appium_server, options=AppiumOptions().load_capabilities(capabilities)
+        )
 
-    elif platform == 'android':
-        appium_server = f'http://{appium_server}/wd/hub'
+    elif platform == "android":
+        appium_server = f"http://{appium_server}/wd/hub"
         capabilities = {
             "platformName": "Android",
             "automationName": "uiautomator2",
-            "deviceName": platform_config.get('deviceName', 'Android'),
-            "appPackage": platform_config.get('appPackage'),
-            "appActivity": platform_config.get('appActivity'),
+            "deviceName": platform_config.get("deviceName", "Android"),
+            "appPackage": platform_config.get("appPackage"),
+            "appActivity": platform_config.get("appActivity"),
             "language": "en",
             "locale": "US",
-            }
+        }
         return appium_webdriver.Remote(
-            appium_server,
-            options=AppiumOptions().load_capabilities(capabilities)
-            )
+            appium_server, options=AppiumOptions().load_capabilities(capabilities)
+        )
 
-    elif platform == 'web':
-        browser = platform_config.get('browser', 'chrome').lower()
-        if browser == 'chrome':
+    elif platform == "web":
+        browser = platform_config.get("browser", "chrome").lower()
+        if browser == "chrome":
             options = ChromeOptions()
-            if platform_config.get('headless', False):
-                options.add_argument('--headless')
-            options.add_argument('--no-sandbox')
-            options.add_argument('--disable-dev-shm-usage')
+            if platform_config.get("headless", False):
+                options.add_argument("--headless")
+            options.add_argument("--no-sandbox")
+            options.add_argument("--disable-dev-shm-usage")
             return selenium_webdriver.Chrome(options=options)
-        elif browser == 'firefox':
+        elif browser == "firefox":
             options = FirefoxOptions()
-            if platform_config.get('headless', False):
-                options.add_argument('--headless')
+            if platform_config.get("headless", False):
+                options.add_argument("--headless")
             return selenium_webdriver.Firefox(options=options)
         else:
             raise ValueError(f"Unsupported browser: {browser}")
@@ -245,13 +243,31 @@ def write_to_file(file_path, string_to_write):
 def remove_unexpected_attr(node):
     """Remove unexpected attributes for mobile XML"""
     unexpected_keys = [
-        key for key, value in node.attrib.items()
-        if key not in [
-            "index", "package", "class", "text", "resource-id", "content-desc",
-            "clickable", "scrollable", "bounds", "name", "label", "value",
-            "enabled", "visible", "accessible", "x", "y", "width", "height"
-            ]
+        key
+        for key, value in node.attrib.items()
+        if key
+        not in [
+            "index",
+            "package",
+            "class",
+            "text",
+            "resource-id",
+            "content-desc",
+            "clickable",
+            "scrollable",
+            "bounds",
+            "name",
+            "label",
+            "value",
+            "enabled",
+            "visible",
+            "accessible",
+            "x",
+            "y",
+            "width",
+            "height",
         ]
+    ]
     for key in unexpected_keys:
         del node.attrib[key]
     for child in node:
@@ -278,13 +294,32 @@ def xml_to_dict(xml_element: ET.Element):
 
     # Include all relevant attributes
     expected_attrib = {
-        (key, value) for key, value in xml_element.attrib.items()
-        if key in [
-            "index", "package", "class", "text", "resource-id", "content-desc",
-            "clickable", "scrollable", "bounds", "name", "label", "value",
-            "enabled", "visible", "accessible", "x", "y", "width", "height"
-            ] and value.strip()
-        }
+        (key, value)
+        for key, value in xml_element.attrib.items()
+        if key
+        in [
+            "index",
+            "package",
+            "class",
+            "text",
+            "resource-id",
+            "content-desc",
+            "clickable",
+            "scrollable",
+            "bounds",
+            "name",
+            "label",
+            "value",
+            "enabled",
+            "visible",
+            "accessible",
+            "x",
+            "y",
+            "width",
+            "height",
+        ]
+        and value.strip()
+    }
     if expected_attrib:
         result.update(expected_attrib)
     return result
@@ -304,12 +339,12 @@ def xml_str_to_yaml(yaml_file, xml_str):
 
 def take_page_source(driver, folder, name, platform):
     """Take page source based on platform"""
-    if platform == 'web':
+    if platform == "web":
         page_source = driver.page_source
         write_to_file(f"{folder}/{name}.html", page_source)
         write_to_file(
             f"{folder}/{name}.yaml", page_source
-            )  # For web, just save HTML as text
+        )  # For web, just save HTML as text
         return f"{folder}/{name}.yaml"
     else:
         # Mobile platforms
@@ -321,7 +356,7 @@ def take_screenshot(driver, folder, name, platform):
     """Take screenshot based on platform"""
     screenshot_path = f"{folder}/{name}.png"
 
-    if platform == 'web':
+    if platform == "web":
         driver.save_screenshot(screenshot_path)
     else:
         # Mobile platforms
@@ -355,21 +390,29 @@ def process_next_action(action, driver, folder, step_name, platform):
 
     try:
         if data["action"] == "tap":
-            if platform == 'web':
+            if platform == "web":
                 process_web_click(data, driver)
             else:
                 process_mobile_tap(data, driver)
             data["result"] = "success"
 
         elif data["action"] == "input":
-            if platform == 'web':
+            if platform == "web":
                 process_web_input(data, driver)
             else:
                 process_mobile_input(data, driver)
             data["result"] = "success"
 
+        elif data["action"] == "read":
+            if platform == "web":
+                text = process_web_read(data, driver)
+            else:
+                text = process_mobile_read(data, driver)
+            data["text"] = text
+            data["result"] = "success"
+
         elif data["action"] == "swipe":
-            if platform == 'web':
+            if platform == "web":
                 process_web_scroll(data, driver)
             else:
                 process_mobile_swipe(data, driver)
@@ -397,12 +440,12 @@ def process_web_click(data, driver):
     if "xpath" in data:
         element = WebDriverWait(driver, 10).until(
             EC.element_to_be_clickable((By.XPATH, data["xpath"]))
-            )
+        )
         element.click()
     elif "css" in data:
         element = WebDriverWait(driver, 10).until(
             EC.element_to_be_clickable((By.CSS_SELECTOR, data["css"]))
-            )
+        )
         element.click()
     elif "bounds" in data:
         # For web, we'll need to convert bounds to element coordinates
@@ -412,7 +455,7 @@ def process_web_click(data, driver):
         click_y = top + (bottom - top) / 2
         driver.execute_script(
             f"document.elementFromPoint({click_x}, {click_y}).click();"
-            )
+        )
 
 
 def process_mobile_tap(data, driver):
@@ -433,13 +476,13 @@ def process_web_input(data, driver):
     if "xpath" in data:
         element = WebDriverWait(driver, 10).until(
             EC.presence_of_element_located((By.XPATH, data["xpath"]))
-            )
+        )
         element.clear()
         element.send_keys(data["value"])
     elif "css" in data:
         element = WebDriverWait(driver, 10).until(
             EC.presence_of_element_located((By.CSS_SELECTOR, data["css"]))
-            )
+        )
         element.clear()
         element.send_keys(data["value"])
 
@@ -469,6 +512,58 @@ def process_mobile_input(data, driver):
             pass
 
 
+def process_web_read(data, driver):
+    """Read text from a web element"""
+    if "xpath" in data:
+        element = WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.XPATH, data["xpath"]))
+        )
+        return element.text
+    if "css" in data:
+        element = WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, data["css"]))
+        )
+        return element.text
+    if "bounds" in data:
+        left, top, right, bottom = parse_bounds(data["bounds"])
+        click_x = left + (right - left) / 2
+        click_y = top + (bottom - top) / 2
+        script = (
+            "return document.elementFromPoint(arguments[0], arguments[1]).textContent;"
+        )
+        return driver.execute_script(script, click_x, click_y)
+    raise KeyError("No locator provided for read action")
+
+
+def process_mobile_read(data, driver):
+    """Read text from a mobile element"""
+    element = None
+    if "xpath" in data:
+        element = driver.find_element(AppiumBy.XPATH, data["xpath"])
+    elif "bounds" in data:
+        left, top, right, bottom = parse_bounds(data["bounds"])
+        for elem in driver.find_elements(AppiumBy.XPATH, "//*"):
+            ex = int(elem.get_attribute("x"))
+            ey = int(elem.get_attribute("y"))
+            ew = int(elem.get_attribute("width"))
+            eh = int(elem.get_attribute("height"))
+            if ex == left and ey == top and ex + ew == right and ey + eh == bottom:
+                element = elem
+                break
+        if element is None:
+            raise ValueError("Element with specified bounds not found")
+    else:
+        raise KeyError("No locator provided for read action")
+
+    text = (
+        element.text
+        or element.get_attribute("value")
+        or element.get_attribute("label")
+        or element.get_attribute("name")
+    )
+    return text or ""
+
+
 def process_web_scroll(data, driver):
     """Process web scroll action"""
     scroll_x = data.get("swipe_end_x", 0) - data.get("swipe_start_x", 0)
@@ -483,9 +578,7 @@ def process_mobile_swipe(data, driver):
     swipe_end_x = data["swipe_end_x"]
     swipe_end_y = data["swipe_end_y"]
     duration = data.get("duration", 500)
-    driver.swipe(
-        swipe_start_x, swipe_start_y, swipe_end_x, swipe_end_y, duration
-        )
+    driver.swipe(swipe_start_x, swipe_start_y, swipe_end_x, swipe_end_y, duration)
     sleep(duration / 1000)
 
 
@@ -498,7 +591,7 @@ def keep_driver_live(driver, platform):
     """Keep driver alive based on platform"""
     try:
         while driver:
-            if platform == 'web':
+            if platform == "web":
                 driver.current_url
             else:
                 driver.page_source
@@ -514,13 +607,9 @@ def keep_driver_live(driver, platform):
     parser.add_argument("config", help="Platform configuration file")
     parser.add_argument(
         "--appium", default="localhost:4723", help="Appium server (for mobile)"
-        )
-    parser.add_argument(
-        "--debug", action="store_true", help="Enable debug mode"
-        )
-    parser.add_argument(
-        "--reports", default="./reports", help="Reports folder"
-        )
+    )
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    parser.add_argument("--reports", default="./reports", help="Reports folder")
 
     args = parser.parse_args()
 
@@ -530,11 +619,11 @@ def keep_driver_live(driver, platform):
 
     # Create driver based on platform
     driver = create_driver(args.appium, platform_config)
-    platform = platform_config.get('platform', '').lower()
+    platform = platform_config.get("platform", "").lower()
 
     # For web, navigate to initial URL
-    if platform == 'web' and 'url' in platform_config:
-        driver.get(platform_config['url'])
+    if platform == "web" and "url" in platform_config:
+        driver.get(platform_config["url"])
 
     driver.implicitly_wait(0.2)
     thread = threading.Thread(target=lambda: keep_driver_live(driver, platform))
@@ -550,9 +639,7 @@ def keep_driver_live(driver, platform):
             print(f"Skipping {name}")
             continue
 
-        task_folder = create_folder(
-            f"{args.reports}/{name}/{get_current_timestamp()}"
-            )
+        task_folder = create_folder(f"{args.reports}/{name}/{get_current_timestamp()}")
         write_to_file(f"{task_folder}/task.json", json.dumps(task))
         write_to_file(f"{task_folder}/config.json", json.dumps(platform_config))
 
@@ -565,10 +652,10 @@ def keep_driver_live(driver, platform):
 
         page_source_file = take_page_source(
             driver, task_folder, "step_0", detected_platform
-            )
+        )
         screenshot_file = take_screenshot(
             driver, task_folder, "step_0", detected_platform
-            )
+        )
 
         history_actions = []
         step = 0
@@ -580,16 +667,19 @@ def keep_driver_live(driver, platform):
                 next_action = input("Next action: ")
             else:
                 next_action = generate_next_action(
-                    prompt, details, history_actions,
-                    page_source_file, screenshot_file, detected_platform
-                    )
+                    prompt,
+                    details,
+                    history_actions,
+                    page_source_file,
+                    screenshot_file,
+                    detected_platform,
+                )
 
             print(f"Step {step}: {next_action}")
 
             page_source_file, screenshot_file, action_result = process_next_action(
-                next_action, driver, task_folder, f"step_{step}",
-                detected_platform
-                )
+                next_action, driver, task_folder, f"step_{step}", detected_platform
+            )
 
             write_to_file(f"{task_folder}/step_{step}.json", action_result)
             history_actions.append(action_result)
@@ -602,4 +692,4 @@ def keep_driver_live(driver, platform):
     try:
         driver.quit()
     except:
-        pass
\ No newline at end of file
+        pass
diff --git a/prompt.md b/prompt.md
index 9ef3223..4718953 100644
--- a/prompt.md
+++ b/prompt.md
@@ -4,7 +4,7 @@ You are a universal automation testing assistant that works across Android, iOS,
 # Task
 Your job is to determine the next course of action for the given task across different platforms.
 
-The set of actions available are: tap/click, input, swipe/scroll, wait, error, or finish. Format should be JSON.
+The set of actions available are: tap/click, input, swipe/scroll, read, wait, error, or finish. Format should be JSON.
 
 ## Platform-Specific Action Examples:
 
@@ -12,17 +12,20 @@ The set of actions available are: tap/click, input, swipe/scroll, wait, error, o
 - {"action": "tap", "xpath": "//XCUIElementTypeButton[@name='Info']", "explanation": "Tap Info button using iOS xpath"}
 - {"action": "tap", "bounds": "[8,20][48,64]", "explanation": "Tap Info button using iOS bounds calculated from x,y,width,height"}
 - {"action": "input", "xpath": "//XCUIElementTypeTextField[@name='username']", "value": "testuser", "explanation": "Input text in iOS text field"}
+- {"action": "read", "xpath": "//XCUIElementTypeStaticText[@name='Version']", "explanation": "Read Version label text"}
 
 ### Android Examples:
 - {"action": "tap", "xpath": "//*[@text='Settings']", "explanation": "Tap Settings using Android text attribute"}
 - {"action": "tap", "bounds": "[22,1117][336,1227]", "explanation": "Tap using Android bounds attribute"}
 - {"action": "input", "xpath": "//*[@resource-id='com.app:id/username']", "value": "testuser", "explanation": "Input text using Android resource-id"}
+- {"action": "read", "xpath": "//*[@content-desc='version']", "explanation": "Read version text"}
 
 ### Web Examples:
 - {"action": "tap", "xpath": "//button[text()='Submit']", "explanation": "Click Submit button using web xpath"}
 - {"action": "tap", "css": "#submit-btn", "explanation": "Click Submit button using CSS selector"}
 - {"action": "input", "xpath": "//input[@id='username']", "value": "testuser", "explanation": "Input text in web form field"}
 - {"action": "swipe", "swipe_start_x": 0, "swipe_start_y": 0, "swipe_end_x": 0, "swipe_end_y": -300, "duration": 500, "explanation": "Scroll down on web page"}
+- {"action": "read", "xpath": "//span[@id='version']", "explanation": "Read version text from web page"}
 
 ### Universal Examples:
 - {"action": "wait", "timeout": 5000, "explanation": "Wait for content to load"}
diff --git a/tasks.json b/tasks.json
index 7ddba2c..867d357 100644
--- a/tasks.json
+++ b/tasks.json
@@ -1,7 +1,12 @@
 [
     {
-        "task": "check version of FortiToken Mobile",
-        "details": "When you use FortiToken Mobile, always check the Version while clicking Info button, recording the steps. When you see version, record the number and stop testing",
+        "task": "Tap Info button",
+        "details": "Tap Info button",
+        "skip": false
+    },
+    {
+        "task": "Read the value of Version",
+        "details": "Read the value of Version",
         "skip": false
     }
-]
\ No newline at end of file
+]
