diff --git a/.env-sample b/.env-sample
new file mode 100644
index 00000000..b0f4dffb
--- /dev/null
+++ b/.env-sample
@@ -0,0 +1,6 @@
+OPENAI_API_KEY=YOUR_OPENAI_API_KEY
+GOOGLE_API_KEY=YOUR_GOOGLE_API_KEY
+OLLAMA_HOST='http://localhost:11434/'
+CUSTOM_SYSTEM_PROMPT='You are a helpful assistant that can perform tasks on a computer. You can execute commands, answer questions, and assist with various tasks. Your goal is to help the user efficiently and effectively.'
+OPENROUTER_API_KEY='sddfsdf'
+OPENROUTER_MODEL="google/gemini-2.0-flash-exp:free"
\ No newline at end of file
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
new file mode 100644
index 00000000..f25d2162
--- /dev/null
+++ b/.github/workflows/python-publish.yml
@@ -0,0 +1,48 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write  # Required for PyPI trusted publishing
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/self-ai-operating-computer
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    
+    - name: Install build tools
+      run: python -m pip install build setuptools wheel
+      
+    - name: Build package
+      run: python -m build
+      
+    - name: Check if version exists on PyPI
+      id: check-version
+      run: |
+        VERSION=$(python setup.py --version)
+        if curl -s "https://pypi.org/pypi/self-ai-operating-computer/$VERSION/json" | grep -q "Not Found"; then
+          echo "version_exists=false" >> $GITHUB_OUTPUT
+        else
+          echo "version_exists=true" >> $GITHUB_OUTPUT
+          echo "Version $VERSION already exists on PyPI. Skipping upload."
+          exit 1
+        fi
+    
+    - name: Publish to PyPI
+      if: steps.check-version.outputs.version_exists == 'false'
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        packages-dir: dist/
diff --git a/.gitignore b/.gitignore
index f23fd690..adeb97b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -162,5 +162,6 @@ cython_debug/
 .DS_Store
 
 # Avoid sending testing screenshots up
-*.png
+# *.png
 operate/screenshots/
+screenshots/*
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1d4ba68c..717920fb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -31,8 +31,8 @@ It is recommended that a screenshot of the `evaluate.py` output is included in a
 - **Improve the `SUMMARY_PROMPT`**
 - **Improve Linux and Windows compatibility**: There are still some issues with Linux and Windows compatibility. PRs to fix the issues are encouraged. 
 - **Adding New Multimodal Models**: Integration of new multimodal models is welcomed. If you have a specific model in mind that you believe would be a valuable addition, please feel free to integrate it and submit a PR.
-- **Iterate `--accurate` flag functionality**: Look at https://github.com/OthersideAI/self-operating-computer/pull/57 for previous iteration
-- **Enhanced Security**: A feature request to implement a _robust security feature_ that prompts users for _confirmation before executing potentially harmful actions_. This feature aims to _prevent unintended actions_ and _safeguard user data_ as mentioned here in this [OtherSide#25](https://github.com/OthersideAI/self-operating-computer/issues/25)
+- **Iterate `--accurate` flag functionality**: Look at https://github.com/malah-code/self-ai-operating-computer/pull/57 for previous iteration
+- **Enhanced Security**: A feature request to implement a _robust security feature_ that prompts users for _confirmation before executing potentially harmful actions_. This feature aims to _prevent unintended actions_ and _safeguard user data_ as mentioned here in this [OtherSide#25](https://github.com/malah-code/self-ai-operating-computer/issues/25)
 
 
 ## Guidelines
diff --git a/LICENSE b/LICENSE
index 2013c4aa..e5061acf 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 OthersideAI
+Copyright (c) 2023 malah-code
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..540b7204
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1 @@
+include requirements.txt
\ No newline at end of file
diff --git a/README.md b/README.md
index 221b3fd8..a090c443 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,7 @@ ome
 <p align="center">
   <strong>A framework to enable multimodal models to operate a computer.</strong>
 </p>
-<p align="center">
-  Using the same inputs and outputs as a human operator, the model views the screen and decides on a series of mouse and keyboard actions to reach an objective. Released Nov 2023, the Self-Operating Computer Framework was one of the first examples of using a multimodal model to view the screen and operate a computer.
-</p>
-
-<div align="center">
-  <img src="https://github.com/OthersideAI/self-operating-computer/blob/main/readme/self-operating-computer.png" width="750"  style="margin: 10px;"/>
-</div>
+ce
 
 <!--
 :rotating_light: **OUTAGE NOTIFICATION: gpt-4o**
@@ -20,34 +14,131 @@ ome
 
 ## Key Features
 - **Compatibility**: Designed for various multimodal models.
-- **Integration**: Currently integrated with **GPT-4o, GPT-4.1, o1, Gemini Pro Vision, Claude 3, Qwen-VL and LLaVa.**
+- **Centralized Model Management**: All model configurations are now managed in a single, easy-to-update file (`operate/models/model_configs.py`), simplifying the addition and management of new models.
+- **Expanded Model Support**: Now integrated with the latest **OpenAI o3, o4-mini, GPT-4.1, GPT-4.1 mini, GPT-4.1 nano**, **Gemini 2.5 Pro, Gemini 2.5 Flash**, and **Gemma 3n** models (including `e2b` and `e4b` variants), and **Gemma 3:12b** alongside existing support for GPT-4o, Claude 3, Qwen-VL, and LLaVa.
+- **Enhanced Ollama Integration**: Improved handling for Ollama models, including default host configuration and more informative error messages.
 - **Future Plans**: Support for additional models.
 
+## Debugging
+
+To gain deeper insights into the model's behavior and troubleshoot issues, you can run `operate` with the `-d` or `--verbose` flag. This will enable verbose mode, providing detailed debugging information directly in your terminal.
+
+```bash
+operate -d
+# or
+operate --verbose
+```
+
+When verbose mode is active, you will see:
+
+*   **Prompt Sent to AI:** The exact JSON prompt that is constructed and sent to the language model for its decision.
+*   **Response from AI:** The raw JSON response received back from the language model.
+
+This detailed output is invaluable for understanding why the model made a particular decision, identifying issues with prompt construction, or debugging unexpected model behaviors.
+
+## Adding New Models
+
+With the introduction of centralized model management, adding new models to the Self-Operating Computer Framework is straightforward. All model configurations are now defined in a single file: `operate/models/model_configs.py`.
+
+To add a new model:
+
+1.  **Locate `model_configs.py`**: Navigate to `operate/models/model_configs.py` in your project directory.
+
+2.  **Understand the `MODELS` Dictionary**: This file contains a Python dictionary named `MODELS`. Each key in this dictionary is the internal identifier for a model (e.g., `"gpt-4o"`, `"llava"`), and its value is another dictionary containing the model's configuration.
+
+    Each model configuration dictionary has the following keys:
+    *   `"api_key"` (string): The name of the environment variable that stores the API key required for this model (e.g., `"OPENAI_API_KEY"`, `"GOOGLE_API_KEY"`, `"OLLAMA_HOST"`). If no API key is needed, you can omit this key or set its value to `None`.
+    *   `"provider"` (string): The service provider for the model (e.g., `"openai"`, `"google"`, `"ollama"`, `"anthropic"`, `"qwen"`). For OpenRouter models, the provider is internally set to `"openrouter_internal"` to ensure proper routing. This string directly corresponds to the logic implemented in `operate/models/apis.py` that handles API calls for that provider.
+    *   `"display_name"` (string): The user-friendly name that will appear in the interactive model selection menu when you run `operate` without specifying a model.
+
+3.  **Add Your New Model Entry**: Append a new entry to the `MODELS` dictionary following the existing format. For example, to add a hypothetical new Ollama model:
+
+    ```python
+    MODELS = {
+        # ... existing models ...
+        "my-new-ollama-model": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "My New Ollama Model (via Ollama)"},
+    }
+    ```
+
+4.  **Ensure Provider Logic Exists**: The `"provider"` you specify (e.g., `"ollama"`) must have corresponding API call logic implemented in `operate/models/apis.py`. If you are adding a model from an existing provider (like OpenAI, Google, Ollama, Anthropic, or Qwen), the existing logic should handle it. If it's a completely new provider, you would need to add the necessary API integration code in `operate/models/apis.py`.
+
+By following these steps, you can easily extend the framework to support new models without modifying core application logic in multiple places.
+
 ## Demo
-https://github.com/OthersideAI/self-operating-computer/assets/42594239/9e8abc96-c76a-46fb-9b13-03678b3c67e0
+https://github.com/malah-code/self-ai-operating-computer/assets/42594239/9e8abc96-c76a-46fb-9b13-03678b3c67e0
 
 
 ## Run `Self-Operating Computer`
 
-1. **Install the project**
-```
-pip install self-operating-computer
-```
-2. **Run the project**
-```
-operate
-```
-3. **Enter your OpenAI Key**: If you don't have one, you can obtain an OpenAI key [here](https://platform.openai.com/account/api-keys). If you need you change your key at a later point, run `vim .env` to open the `.env` and replace the old key. 
+### Run from PyPI
+
+To run the application by installing it from PyPI, follow these steps:
+
+1.  **Install the project:**
+    ```bash
+    pip install self-ai-operating-computer
+    ```
+2.  **Run the project:**
+    ```bash
+    operate
+    ```
+
+### Run from Source Code
+
+To run the application from your local copy (after making changes), follow these steps:
+
+1.  **Uninstall previous installations (if any):**
+    ```bash
+    pip uninstall self-ai-operating-computer
+    ```
+    Confirm uninstallation when prompted.
+
+2.  **Install in editable mode:**
+    Navigate to the project's root directory (where `setup.py` is located) and run:
+    ```bash
+    pip install -e .
+    ```
+    This links your local source code to your Python environment, so changes are immediately reflected.
+
+3.  **Run the project:**
+    ```bash
+    operate
+    ```
+    If you run `operate` without any arguments, a welcome screen will be displayed, followed by an interactive model selection menu. If a model requires an API key that is not found in your environment variables or `.env` file, you will be prompted to enter it.
+
+    You can also specify the OpenRouter model directly via an environment variable to bypass the interactive selection:
+    ```bash
+    export OPENROUTER_MODEL="openai/gpt-4o-mini"
+    operate -m openrouter
+    ```
+    Or for other models:
+    ```bash
+    export OPENROUTER_MODEL="google/gemini-2.5-pro"
+    operate -m openrouter
+    ```
+
+<div align="center">
+  <img src="/readme/choose-model.png" width="750"  style="max-width: 100%;"/>
+</div>
+
+Once you select a model, you will be prompted to provide a custom system prompt if the `CUSTOM_SYSTEM_PROMPT` environment variable is not set. If the environment variable is set, the prompt screen will be skipped and the value from the environment variable will be used automatically. You can also load the prompt from a file if needed.
 
 <div align="center">
-  <img src="https://github.com/OthersideAI/self-operating-computer/blob/main/readme/key.png" width="300"  style="margin: 10px;"/>
+  <img src="/readme/system-parameter-1.png" width="750"  style="max-width: 100%;"/>
+  <img src="/readme/prompt1.png" width="750"  style="max-width: 100%;"/>
 </div>
 
-4. **Give Terminal app the required permissions**: As a last step, the Terminal app will ask for permission for "Screen Recording" and "Accessibility" in the "Security & Privacy" page of Mac's "System Preferences".
+4.  **Enter your OpenAI Key**: If you don't have one, you can obtain an OpenAI key [here](https://platform.openai.com/account/api-keys). If you need you change your key at a later point, run `vim .env` to open the `.env` and replace the old key. 
 
 <div align="center">
-  <img src="https://github.com/OthersideAI/self-operating-computer/blob/main/readme/terminal-access-1.png" width="300"  style="margin: 10px;"/>
-  <img src="https://github.com/OthersideAI/self-operating-computer/blob/main/readme/terminal-access-2.png" width="300"  style="margin: 10px;"/>
+  <img src="/readme/key.png" width="300"  style="margin: 10px;"/>
+</div>
+
+5.  **Give Terminal app the required permissions**: As a last step, the Terminal app will ask for permission for "Screen Recording" and "Accessibility" in the "Security & Privacy" page of Mac's "System Preferences".
+
+<div align="center">
+  <img src="/readme/terminal-access-1.png" width="300"  style="margin: 10px;"/>
+  <img src="/readme/terminal-access-2.png" width="300"  style="margin: 10px;"/>
 </div>
 
 ## Using `operate` Modes
@@ -63,14 +154,38 @@ operate -m o1-with-ocr
 To experiment with OpenAI's latest `gpt-4.1` model, run:
 
 ```
-operate -m gpt-4.1-with-ocr
+operate -m gpt-4.1
+```
+
+To experiment with OpenAI's latest `gpt-4.1 mini` model, run:
+
+```
+operate -m gpt-4.1-mini
+```
+
+To experiment with OpenAI's latest `gpt-4.1 nano` model, run:
+
+```
+operate -m gpt-4.1-nano
+```
+
+To experiment with OpenAI's latest `o3` model, run:
+
+```
+operate -m o3
+```
+
+To experiment with OpenAI's latest `o4-mini` model, run:
+
+```
+operate -m o4-mini
 ```
 
 
 ### Multimodal Models  `-m`
-Try Google's `gemini-pro-vision` by following the instructions below. Start `operate` with the Gemini model
+Try Google's `gemini-1.5-pro-latest`, `gemini-2.5-pro`, or `gemini-2.5-flash` by following the instructions below. Start `operate` with the Gemini model
 ```
-operate -m gemini-pro-vision
+operate -m gemini-2.5-pro
 ```
 
 **Enter your Google AI Studio API key when terminal prompts you for it** If you don't have one, you can obtain a key [here](https://makersuite.google.com/app/apikey) after setting up your Google AI Studio account. You may also need [authorize credentials for a desktop application](https://ai.google.dev/palm_docs/oauth_quickstart). It took me a bit of time to get it working, if anyone knows a simpler way, please make a PR.
@@ -91,7 +206,6 @@ operate -m qwen-vl
 
 #### Try LLaVa Hosted Through Ollama `-m llava`
 If you wish to experiment with the Self-Operating Computer Framework using LLaVA on your own machine, you can with Ollama!   
-*Note: Ollama currently only supports MacOS and Linux. Windows now in Preview*   
 
 First, install Ollama on your machine from https://ollama.ai/download.   
 
@@ -112,17 +226,61 @@ operate -m llava
 ```   
 **Important:** Error rates when using LLaVA are very high. This is simply intended to be a base to build off of as local multimodal models improve over time.
 
+#### Try Gemma 3n Hosted Through Ollama `-m gemma3n`
+If you wish to experiment with the Self-Operating Computer Framework using Gemma 3n on your own machine, you can with Ollama!   
+*Note: Ollama currently only supports MacOS and Linux. Windows now in Preview*   
+
+First, install Ollama on your machine from https://ollama.ai/download.   
+
+Once Ollama is installed, pull the Gemma 3n model:
+```
+ollama pull gemma3n
+```
+This will download the model on your machine. You can also pull specific versions like `ollama pull gemma3n:e2b` or `ollama pull gemma3n:e4b`.
+
+When Ollama has finished pulling Gemma 3n, start the server:
+```
+ollama serve
+```
+
+That's it! Now start `operate` and select the Gemma 3n model. You can specify `gemma3n`, `gemma3n:e2b`, or `gemma3n:e4b`:
+```
+operate -m gemma3n:e2b
+```   
+
+#### Try Gemma 3:12b Hosted Through Ollama `-m gemma3:12b`
+If you wish to experiment with the Self-Operating Computer Framework using Gemma 3:12b on your own machine, you can with Ollama!   
+*Note: Ollama currently only supports MacOS and Linux. Windows now in Preview*   
+
+First, install Ollama on your machine from https://ollama.ai/download.   
+
+Once Ollama is installed, pull the Gemma 3:12b model:
+```
+ollama pull gemma3:12b
+```
+This will download the model on your machine.   
+
+When Ollama has finished pulling Gemma 3:12b, start the server:
+```
+ollama serve
+```
+
+That's it! Now start `operate` and select the Gemma 3:12b model:
+```
+operate -m gemma3:12b
+```   
+
 Learn more about Ollama at its [GitHub Repository](https://www.github.com/ollama/ollama)
 
 ### Voice Mode `--voice`
 The framework supports voice inputs for the objective. Try voice by following the instructions below. 
 **Clone the repo** to a directory on your computer:
 ```
-git clone https://github.com/OthersideAI/self-operating-computer.git
+git clone https://github.com/malah-code/self-ai-operating-computer.git
 ```
 **Cd into directory**:
 ```
-cd self-operating-computer
+cd self-ai-operating-computer
 ```
 Install the additional `requirements-audio.txt`
 ```
@@ -166,7 +324,7 @@ operate -m gpt-4-with-som
 
 ## Contributions are Welcomed!:
 
-If you want to contribute yourself, see [CONTRIBUTING.md](https://github.com/OthersideAI/self-operating-computer/blob/main/CONTRIBUTING.md).
+If you want to contribute yourself, see [CONTRIBUTING.md](/CONTRIBUTING.md).
 
 ## Feedback
 
@@ -175,18 +333,127 @@ For any input on improving this project, feel free to reach out to [Josh](https:
 ## Join Our Discord Community
 
 For real-time discussions and community support, join our Discord server. 
-- If you're already a member, join the discussion in [#self-operating-computer](https://discord.com/channels/877638638001877052/1181241785834541157).
-- If you're new, first [join our Discord Server](https://discord.gg/YqaKtyBEzM) and then navigate to the [#self-operating-computer](https://discord.com/channels/877638638001877052/1181241785834541157).
+- If you're already a member, join the discussion in [#self-ai-operating-computer](https://discord.com/channels/877638638001877052/1181241785834541157).
+- If you're new, first [join our Discord Server](https://discord.com/channels/877638638001877052/1181241785834541157).
 
 ## Follow HyperWriteAI for More Updates
 
 Stay updated with the latest developments:
 - Follow HyperWriteAI on [Twitter](https://twitter.com/HyperWriteAI).
-- Follow HyperWriteAI on [LinkedIn](https://www.linkedin.com/company/othersideai/).
+- Follow HyperWriteAI on [LinkedIn](https://www.linkedin.com/company/malah-code/).
 
 ## Compatibility
 - This project is compatible with Mac OS, Windows, and Linux (with X server installed).
 
 ## OpenAI Rate Limiting Note
-The ```gpt-4o``` model is required. To unlock access to this model, your account needs to spend at least \$5 in API credits. Pre-paying for these credits will unlock access if you haven't already spent the minimum \$5.   
+The ```gpt-4o``` model is required. To unlock access to this model, your account needs to spend at least $5 in API credits. Pre-paying for these credits will unlock access if you haven't already spent the minimum $5.   
 Learn more **[here](https://platform.openai.com/docs/guides/rate-limits?context=tier-one)**
+
+## Supported Models Summary
+
+Here's a summary of all currently supported models and how to run them:
+
+*   **OpenAI GPT-4o (Default):**
+    ```
+    operate
+    ```
+*   **OpenAI o1-with-ocr:**
+    ```
+    operate -m o1-with-ocr
+    ```
+*   **OpenAI o3:**
+    ```
+    operate -m o3
+    ```
+*   **OpenAI o4-mini:**
+    ```
+    operate -m o4-mini
+    ```
+*   **OpenAI gpt-4.1:**
+    ```
+    operate -m gpt-4.1
+    ```
+*   **OpenAI gpt-4.1 mini:**
+    ```
+    operate -m gpt-4.1-mini
+    ```
+*   **OpenAI gpt-4.1 nano:**
+    ```
+    operate -m gpt-4.1-nano
+    ```
+*   **OpenAI gpt-4-with-ocr:**
+    ```
+    operate -m gpt-4-with-ocr
+    ```
+*   **OpenAI gpt-4-with-som:**
+    ```
+    operate -m gpt-4-with-som
+    ```
+*   **Google Gemini 1.5 Pro (latest):**
+    ```
+    operate -m gemini-1.5-pro-latest
+    ```
+*   **Google Gemini 2.5 Pro:**
+    ```
+    operate -m gemini-2.5-pro
+    ```
+*   **Google Gemini 2.5 Flash:**
+    ```
+    operate -m gemini-2.5-flash
+    ```
+*   **Anthropic Claude 3:**
+    ```
+    operate -m claude-3
+    ```
+*   **Qwen-VL:**
+    ```
+    operate -m qwen-vl
+    ```
+*   **LLaVa (via Ollama):**
+    ```
+    operate -m llava
+    ```
+*   **Gemma 3n (via Ollama):**
+    ```
+    operate -m gemma3n
+    ```
+*   **Gemma 3n:e2b (via Ollama):**
+    ```
+    operate -m gemma3n:e2b
+    ```
+*   **Gemma 3n:e4b (via Ollama):**
+    ```
+    operate -m gemma3n:e4b
+    ```
+*   **Gemma 3:12b (via Ollama):**
+    ```
+    operate -m gemma3:12b
+    ```
+*   **OpenRouter:**
+    ```
+    operate -m openrouter
+    ```
+    (Selecting this option will prompt you to enter the full OpenRouter model name, e.g., `google/gemini-2.0-flash-001`.)
+
+## Release Notes
+
+### Version 0.0.X (Latest)
+
+**New Features:**
+
+*   **Interactive Model Selection:** When running `operate` without specifying a model, a welcome screen is displayed, followed by an interactive menu to select your desired model.
+*   **Dynamic API Key Prompting:** The application now intelligently prompts for required API keys (e.g., OpenAI, Google, Anthropic) only when a model requiring that key is selected and the key is not found in your environment variables or `.env` file.
+*   **Custom System Prompt:** Users can now provide a custom system prompt from a file or an environment variable (`CUSTOM_SYSTEM_PROMPT`). If the environment variable is set, the option to load from it will be hidden.
+
+**Improvements:**
+
+*   **Expanded Google Gemini Support:** Added full support for `gemini-2.5-pro` and `gemini-2.5-flash` models.
+*   **Enhanced Ollama Integration:** Improved handling for Ollama models, including setting `http://localhost:11434` as the default host and providing more informative error messages when Ollama models are not found.
+*   **Gemma 3n Model Support:** Integrated support for `gemma3n`, `gemma3n:e2b`, and `gemma3n:e4b` models via Ollama.
+*   **Robust Error Handling:** Improved error handling for API calls to prevent unexpected fallbacks and provide clearer error messages.
+
+**Bug Fixes:**
+
+*   Resolved an issue where the application would incorrectly prompt for an OpenAI API key when a Google Gemini model was selected.
+*   Fixed an issue where the application would attempt to use an incorrect model name for `gemini-2.5-flash-lite` (which is not a valid model name).
+*   Addressed the "Extra data" JSON parsing error when receiving responses from Gemini models.
diff --git a/evaluate.py b/evaluate.py
index 0c73ba59..4f455110 100644
--- a/evaluate.py
+++ b/evaluate.py
@@ -135,7 +135,7 @@ def run_test_case(objective, guideline, model):
 
 def get_test_model():
     parser = argparse.ArgumentParser(
-        description="Run the self-operating-computer with a specified model."
+        description="Run the self-ai-operating-computer with a specified model."
     )
 
     parser.add_argument(
diff --git a/operate/config.py b/operate/config.py
index 09f78da0..d1891dfa 100644
--- a/operate/config.py
+++ b/operate/config.py
@@ -7,6 +7,7 @@
 from openai import OpenAI
 import anthropic
 from prompt_toolkit.shortcuts import input_dialog
+from operate.models.model_configs import MODELS
 
 
 class Config:
@@ -34,15 +35,15 @@ def __init__(self):
         self.openai_api_key = (
             None  # instance variables are backups in case saving to a `.env` fails
         )
-        self.google_api_key = (
-            None  # instance variables are backups in case saving to a `.env` fails
-        )
         self.ollama_host = (
             None  # instance variables are backups in case savint to a `.env` fails
         )
         self.anthropic_api_key = (
             None  # instance variables are backups in case saving to a `.env` fails
         )
+        self.openrouter_api_key = (
+            None  # instance variables are backups in case saving to a `.env` fails
+        )
         self.qwen_api_key = (
             None  # instance variables are backups in case saving to a `.env` fails
         )
@@ -92,19 +93,10 @@ def initialize_qwen(self):
         client.base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
         return client
 
-    def initialize_google(self):
-        if self.google_api_key:
-            if self.verbose:
-                print("[Config][initialize_google] using cached google_api_key")
-            api_key = self.google_api_key
-        else:
-            if self.verbose:
-                print(
-                    "[Config][initialize_google] no cached google_api_key, try to get from env."
-                )
-            api_key = os.getenv("GOOGLE_API_KEY")
+    def initialize_google(self, model_name="gemini-1.5-pro-latest"):
+        api_key = os.getenv("GOOGLE_API_KEY")
         genai.configure(api_key=api_key, transport="rest")
-        model = genai.GenerativeModel("gemini-pro-vision")
+        model = genai.GenerativeModel(model_name)
 
         return model
 
@@ -117,7 +109,7 @@ def initialize_ollama(self):
                 print(
                     "[Config][initialize_ollama] no cached ollama host. Assuming ollama running locally."
                 )
-            self.ollama_host = os.getenv("OLLAMA_HOST", None)
+            self.ollama_host = os.getenv("OLLAMA_HOST", "http://localhost:11434")
         model = Client(host=self.ollama_host)
         return model
 
@@ -128,27 +120,31 @@ def initialize_anthropic(self):
             api_key = os.getenv("ANTHROPIC_API_KEY")
         return anthropic.Anthropic(api_key=api_key)
 
+    def initialize_openrouter(self):
+        if self.openrouter_api_key:
+            api_key = self.openrouter_api_key
+        else:
+            api_key = os.getenv("OPENROUTER_API_KEY")
+        return OpenAI(api_key=api_key, base_url="https://openrouter.ai/api/v1")
+
     def validation(self, model, voice_mode):
         """
         Validate the input parameters for the dialog operation.
         """
-        self.require_api_key(
-            "OPENAI_API_KEY",
-            "OpenAI API key",
-            model == "gpt-4"
-            or voice_mode
-            or model == "gpt-4-with-som"
-            or model == "gpt-4-with-ocr"
-            or model == "gpt-4.1-with-ocr"
-            or model == "o1-with-ocr",
-        )
-        self.require_api_key(
-            "GOOGLE_API_KEY", "Google API key", model == "gemini-pro-vision"
-        )
-        self.require_api_key(
-            "ANTHROPIC_API_KEY", "Anthropic API key", model == "claude-3"
-        )
-        self.require_api_key("QWEN_API_KEY", "Qwen API key", model == "qwen-vl")
+        if model in MODELS:
+            model_config = MODELS[model]
+            provider = model_config.get("provider")
+            api_key_name = model_config.get("api_key")
+
+            if api_key_name:
+                self.require_api_key(api_key_name, f"{provider} API key", True)
+
+        if voice_mode and model not in [m for m, c in MODELS.items() if c.get('provider') == 'google']:
+            self.require_api_key("OPENAI_API_KEY", "OpenAI API key", True)
+
+        if model in MODELS and MODELS[model].get("provider") == "openrouter":
+            self.require_api_key("OPENROUTER_API_KEY", "OpenRouter API key", True)
+
 
     def require_api_key(self, key_name, key_description, is_required):
         key_exists = bool(os.environ.get(key_name))
@@ -157,7 +153,7 @@ def require_api_key(self, key_name, key_description, is_required):
             print("[Config] key_name", key_name)
             print("[Config] key_description", key_description)
             print("[Config] key_exists", key_exists)
-        if is_required and not key_exists:
+        if is_required and not key_exists and not getattr(self, key_name.lower(), None):
             self.prompt_and_save_api_key(key_name, key_description)
 
     def prompt_and_save_api_key(self, key_name, key_description):
@@ -169,19 +165,14 @@ def prompt_and_save_api_key(self, key_name, key_description):
             sys.exit("Operation cancelled by user.")
 
         if key_value:
-            if key_name == "OPENAI_API_KEY":
-                self.openai_api_key = key_value
-            elif key_name == "GOOGLE_API_KEY":
-                self.google_api_key = key_value
-            elif key_name == "ANTHROPIC_API_KEY":
-                self.anthropic_api_key = key_value
-            elif key_name == "QWEN_API_KEY":
-                self.qwen_api_key = key_value
+            setattr(self, key_name.lower(), key_value)
+            if key_name == "GOOGLE_API_KEY":
+                os.environ[key_name] = key_value # Explicitly set for current process
             self.save_api_key_to_env(key_name, key_value)
             load_dotenv()  # Reload environment variables
-            # Update the instance attribute with the new key
+
 
     @staticmethod
     def save_api_key_to_env(key_name, key_value):
         with open(".env", "a") as file:
-            file.write(f"\n{key_name}='{key_value}'")
+            file.write(f"\n{key_name}='{key_value}'")
\ No newline at end of file
diff --git a/operate/main.py b/operate/main.py
index 86832e4e..665e5c19 100644
--- a/operate/main.py
+++ b/operate/main.py
@@ -8,14 +8,13 @@
 
 def main_entry():
     parser = argparse.ArgumentParser(
-        description="Run the self-operating-computer with a specified model."
+        description="Run the self-ai-operating-computer with a specified model."
     )
     parser.add_argument(
         "-m",
         "--model",
         help="Specify the model to use",
         required=False,
-        default="gpt-4-with-ocr",
     )
 
     # Add a voice flag
@@ -27,6 +26,7 @@ def main_entry():
     
     # Add a flag for verbose mode
     parser.add_argument(
+        "-d",
         "--verbose",
         help="Run operate in verbose mode",
         action="store_true",
diff --git a/operate/models/apis.py b/operate/models/apis.py
index 23794fca..f32aeb91 100644
--- a/operate/models/apis.py
+++ b/operate/models/apis.py
@@ -25,46 +25,178 @@
 )
 from operate.utils.ocr import get_text_coordinates, get_text_element
 from operate.utils.screenshot import capture_screen_with_cursor, compress_screenshot
-from operate.utils.style import ANSI_BRIGHT_MAGENTA, ANSI_GREEN, ANSI_RED, ANSI_RESET
+from operate.utils.style import (
+    ANSI_BRIGHT_MAGENTA,
+    ANSI_GREEN,
+    ANSI_RED,
+    ANSI_RESET,
+    ANSI_YELLOW,
+)
 
 # Load configuration
 config = Config()
 
+# Define a maximum token limit for OpenRouter models (adjust as needed)
+OPENROUTER_MAX_TOKENS = 15000
+
+
+from operate.models.model_configs import MODELS
 
 async def get_next_action(model, messages, objective, session_id):
     if config.verbose:
         print("[Self-Operating Computer][get_next_action]")
         print("[Self-Operating Computer][get_next_action] model", model)
-    if model == "gpt-4":
-        return call_gpt_4o(messages), None
-    if model == "qwen-vl":
-        operation = await call_qwen_vl_with_ocr(messages, objective, model)
-        return operation, None
-    if model == "gpt-4-with-som":
-        operation = await call_gpt_4o_labeled(messages, objective, model)
-        return operation, None
-    if model == "gpt-4-with-ocr":
-        operation = await call_gpt_4o_with_ocr(messages, objective, model)
-        return operation, None
-    if model == "gpt-4.1-with-ocr":
-        operation = await call_gpt_4_1_with_ocr(messages, objective, model)
-        return operation, None
-    if model == "o1-with-ocr":
-        operation = await call_o1_with_ocr(messages, objective, model)
-        return operation, None
-    if model == "agent-1":
-        return "coming soon"
-    if model == "gemini-pro-vision":
-        return call_gemini_pro_vision(messages, objective), None
-    if model == "llava":
-        operation = call_ollama_llava(messages)
-        return operation, None
-    if model == "claude-3":
-        operation = await call_claude_3_with_ocr(messages, objective, model)
-        return operation, None
+
+    if config.verbose:
+        print(f"[Self-Operating Computer][get_next_action] Checking model: {model}")
+    if model.startswith("openrouter_internal_"):
+        # Remove the internal prefix before calling the OpenRouter model
+        actual_model_name = model.replace("openrouter_internal_", "")
+        return call_openrouter_model(messages, objective, actual_model_name), None
+
+    if model in MODELS:
+        provider = MODELS[model].get("provider")
+        if provider == "openai":
+            if "-with-ocr" in model or "-with-som" in model:
+                return await call_gpt_4o_with_ocr(messages, objective, model), None
+            return call_gpt_4o(messages), None
+        elif provider == "google":
+            return call_gemini(messages, objective, model), None
+        elif provider == "ollama":
+            return call_ollama_model(messages, model), None
+        elif provider == "anthropic":
+            return await call_claude_3_with_ocr(messages, objective, model), None
+        elif provider == "qwen":
+            return await call_qwen_vl_with_ocr(messages, objective, model), None
+        # If it's "openrouter" from MODELS, it means the user selected the OpenRouter option
+        # The actual OpenRouter model name would have been prompted for and is now in 'model'
+        elif provider == "openrouter":
+            return call_openrouter_model(messages, objective, model), None
+
+    # If the model is not in MODELS, check if it's an OpenRouter model by its format
+    # OpenRouter models typically have a '/' in their name (e.g., "google/gemini-2.0-flash-001")
+    if "/" in model:
+        return call_openrouter_model(messages, objective, model), None
+
     raise ModelNotRecognizedException(model)
 
 
+def call_openrouter_model(messages, objective, model):
+    if config.verbose:
+        print("[call_openrouter_model]")
+    time.sleep(1)
+    client = config.initialize_openrouter()
+    content = None  # Initialize content to None
+    try:
+        screenshots_dir = "screenshots"
+        if not os.path.exists(screenshots_dir):
+            os.makedirs(screenshots_dir)
+
+        screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        # Call the function to capture the screen with the cursor
+        capture_screen_with_cursor(screenshot_filename)
+
+        with open(screenshot_filename, "rb") as img_file:
+            img_base64 = base64.b64encode(img_file.read()).decode("utf-8")
+
+        if len(messages) == 1:
+            user_prompt = get_user_first_message_prompt()
+        else:
+            user_prompt = get_user_prompt()
+
+        if config.verbose:
+            print(
+                "[call_openrouter_model] user_prompt",
+                user_prompt,
+            )
+
+        vision_message = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_prompt},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
+                },
+            ],
+        }
+        messages.append(vision_message)
+
+        # Token management for OpenRouter models
+        current_tokens = 0
+        truncated_messages = [messages[0]]  # Always keep the system prompt
+
+        # Estimate token count and truncate messages if necessary
+        for msg in reversed(messages[1:]):
+            msg_content = ""
+            if isinstance(msg["content"], str):
+                msg_content = msg["content"]
+            elif isinstance(msg["content"], list):
+                for item in msg["content"]:
+                    if item["type"] == "text":
+                        msg_content += item["text"]
+            
+            # Simple character count as a proxy for tokens
+            estimated_tokens = len(msg_content) / 4  # Rough estimate: 1 token ~ 4 characters
+
+            if current_tokens + estimated_tokens < OPENROUTER_MAX_TOKENS:
+                truncated_messages.insert(1, msg)  # Insert after system prompt
+                current_tokens += estimated_tokens
+            else:
+                if config.verbose:
+                    print(f"{ANSI_YELLOW}Truncating messages to stay within token limit. Dropping: {msg.get('role')}{ANSI_RESET}")
+                break
+        
+        # Reverse to maintain chronological order (except system prompt at beginning)
+        truncated_messages = [truncated_messages[0]] + list(reversed(truncated_messages[1:]))
+
+        response = client.chat.completions.create(
+            model=model,
+            messages=truncated_messages,
+            presence_penalty=1,
+            frequency_penalty=1,
+        )
+
+        if config.verbose:
+            print(f"{ANSI_YELLOW}Raw OpenRouter API response: {response}{ANSI_RESET}")
+
+        if not response or not response.choices or not response.choices[0] or not response.choices[0].message:
+            raise Exception("OpenRouter API response is incomplete or malformed.")
+
+        content = response.choices[0].message.content
+
+        if content is None:
+            print(f"{ANSI_RED}[Error] OpenRouter model returned no content.{ANSI_RESET}")
+            return [] # Return an empty list of operations
+
+        content = clean_json(content)
+
+        assistant_message = {"role": "assistant", "content": content}
+        if config.verbose:
+            print(
+                "[call_openrouter_model] content",
+                content,
+            )
+        content = json.loads(content)
+
+        messages.append(assistant_message)
+
+        return content
+
+    except Exception as e:
+        print(
+            f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_BRIGHT_MAGENTA}[Operate] That did not work. {ANSI_RESET}",
+            e,
+        )
+        print(
+            f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_RED}[Error] AI response was {ANSI_RESET}",
+            content,
+        )
+        if config.verbose:
+            traceback.print_exc()
+        raise
+
+
 def call_gpt_4o(messages):
     if config.verbose:
         print("[call_gpt_4_v]")
@@ -259,15 +391,13 @@ async def call_qwen_vl_with_ocr(messages, objective, model):
             traceback.print_exc()
         return gpt_4_fallback(messages, objective, model)
 
-def call_gemini_pro_vision(messages, objective):
+def call_gemini(messages, objective, model_name):
     """
     Get the next action for Self-Operating Computer using Gemini Pro Vision
     """
     if config.verbose:
-        print(
-            "[Self Operating Computer][call_gemini_pro_vision]",
-        )
-    # sleep for a second
+        print(f"[Self Operating Computer][{model_name}]")
+    
     time.sleep(1)
     try:
         screenshots_dir = "screenshots"
@@ -275,40 +405,110 @@ def call_gemini_pro_vision(messages, objective):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
-        # Call the function to capture the screen with the cursor
         capture_screen_with_cursor(screenshot_filename)
-        # sleep for a second
         time.sleep(1)
-        prompt = get_system_prompt("gemini-pro-vision", objective)
-
-        model = config.initialize_google()
+        
+        # Get the system prompt and enhance it with specific instructions
+        prompt = get_system_prompt(model_name, objective)
+        prompt += """
+        IMPORTANT: When providing click coordinates, they MUST be in decimal percentage format (0.0 to 1.0).
+        For example, to click at 25% from the left and 50% from the top, use:
+        {"x": 0.25, "y": 0.50}
+        
+        For interacting with UI elements:
+        1. First, identify the element's position on the screen
+        2. Estimate its center point in percentage (0.0 to 1.0 for both x and y)
+        3. Return a click action with those coordinates
+        
+        For entering phone numbers:
+        1. First click on the input field
+        2. Then use the 'write' operation to type the numbers
+        
+        If you can't determine exact coordinates, make an educated guess based on the UI layout.
+        """
+        
+        # Add specific guidance for calculator operations
+        if "calculator" in objective.lower():
+            prompt += """
+            When interacting with the Calculator app:
+            1. The input field is typically at the top (y ~0.2-0.3)
+            2. Number buttons are in a grid at the bottom
+            3. Operation buttons are on the right side
+            
+            For phone number entry:
+            1. First click on the input field (x: 0.5, y: 0.25)
+            2. Then type the numbers using the 'write' operation
+            3. For a random phone number, use format: 5551234567 (without dashes)
+            """
+        
+        model = config.initialize_google(model_name)
         if config.verbose:
-            print("[call_gemini_pro_vision] model", model)
+            print(f"[{model_name}] model initialized")
 
         response = model.generate_content([prompt, Image.open(screenshot_filename)])
 
-        content = response.text[1:]
+        content = clean_json(response.text)
+        
         if config.verbose:
-            print("[call_gemini_pro_vision] response", response)
-            print("[call_gemini_pro_vision] content", content)
+            print(f"[{model_name}] response:", content)
 
         content = json.loads(content)
-        if config.verbose:
-            print(
-                "[get_next_action][call_gemini_pro_vision] content",
-                content,
-            )
+        
+        # If content is a string, try to parse it as JSON
+        if isinstance(content, str):
+            try:
+                content = json.loads(content)
+            except json.JSONDecodeError:
+                print(f"{ANSI_RED}[Error] Failed to parse response as JSON: {content}{ANSI_RESET}")
+                raise
+        
+        # If content is not a list, wrap it in a list
+        if not isinstance(content, list):
+            content = [content]
+        
+        # Process each action in the content
+        for action in content:
+            if action.get("operation") == "click":
+                x = action.get("x")
+                y = action.get("y")
+                
+                # If coordinates are missing, try to estimate based on the objective
+                if x is None or y is None:
+                    if "calculator" in objective.lower() and "+" in objective.lower():
+                        # Default position for calculator + button (adjust as needed)
+                        action["x"] = 0.85  # Right side of calculator
+                        action["y"] = 0.6   # Vertical middle area where + usually is
+                        action["thought"] = "Moving to the + button in the calculator"
+                        print(f"{ANSI_YELLOW}Using estimated position for calculator + button{ANSI_RESET}")
+                    elif any(word in objective.lower() for word in ["phone", "number", "telephone"]):
+                        # Adjusted position for calculator input field
+                        action["x"] = 0.5    # Middle of screen (calculator should be centered)
+                        action["y"] = 0.25   # Higher up for input field
+                        action["thought"] = "Clicking on the calculator input field to type"
+                        print(f"{ANSI_YELLOW}Using estimated position for calculator input field at (0.5, 0.25){ANSI_RESET}")
+                        
+                        # Add a small delay to ensure calculator is focused
+                        time.sleep(1)
+                    else:
+                        print(f"{ANSI_RED}[Error] Missing x or y coordinates in click action. Please specify where to click.{ANSI_RESET}")
+                        print(f"{ANSI_YELLOW}Hint: Try being more specific about what to click on (e.g., 'click on the input field' or 'click on the + button'){ANSI_RESET}")
+                        raise ValueError("Missing coordinates in click action")
+                
+                # Ensure coordinates are floats
+                try:
+                    action["x"] = float(action["x"])
+                    action["y"] = float(action["y"])
+                except (TypeError, ValueError) as e:
+                    print(f"{ANSI_RED}[Error] Invalid coordinate format: {e}. Expected numbers between 0 and 1.{ANSI_RESET}")
+                    raise
 
         return content
 
     except Exception as e:
-        print(
-            f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_BRIGHT_MAGENTA}[Operate] That did not work. Trying another method {ANSI_RESET}"
-        )
+        print(f"{ANSI_RED}[Error] {e}{ANSI_RESET}")
         if config.verbose:
-            print("[Self-Operating Computer][Operate] error", e)
             traceback.print_exc()
-        return call_gpt_4o(messages)
+        raise
 
 
 async def call_gpt_4o_with_ocr(messages, objective, model):
@@ -326,28 +526,37 @@ async def call_gpt_4o_with_ocr(messages, objective, model):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
-        # Call the function to capture the screen with the cursor
-        capture_screen_with_cursor(screenshot_filename)
+        
+        if config.display_screenshot:
+            # Call the function to capture the screen with the cursor
+            capture_screen_with_cursor(screenshot_filename)
 
-        with open(screenshot_filename, "rb") as img_file:
-            img_base64 = base64.b64encode(img_file.read()).decode("utf-8")
+            with open(screenshot_filename, "rb") as img_file:
+                img_base64 = base64.b64encode(img_file.read()).decode("utf-8")
 
-        if len(messages) == 1:
-            user_prompt = get_user_first_message_prompt()
+            if len(messages) == 1:
+                user_prompt = get_user_first_message_prompt()
+            else:
+                user_prompt = get_user_prompt()
+
+            vision_message = {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": user_prompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
+                    },
+                ],
+            }
+            messages.append(vision_message)
         else:
-            user_prompt = get_user_prompt()
-
-        vision_message = {
-            "role": "user",
-            "content": [
-                {"type": "text", "text": user_prompt},
-                {
-                    "type": "image_url",
-                    "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
-                },
-            ],
-        }
-        messages.append(vision_message)
+            if len(messages) == 1:
+                user_prompt = get_user_first_message_prompt()
+            else:
+                user_prompt = get_user_prompt()
+            vision_message = {"role": "user", "content": user_prompt}
+            messages.append(vision_message)
 
         response = client.chat.completions.create(
             model="gpt-4o",
@@ -438,6 +647,7 @@ async def call_gpt_4_1_with_ocr(messages, objective, model):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        
         capture_screen_with_cursor(screenshot_filename)
 
         with open(screenshot_filename, "rb") as img_file:
@@ -545,6 +755,7 @@ async def call_o1_with_ocr(messages, objective, model):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        
         # Call the function to capture the screen with the cursor
         capture_screen_with_cursor(screenshot_filename)
 
@@ -657,6 +868,7 @@ async def call_gpt_4o_labeled(messages, objective, model):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        
         # Call the function to capture the screen with the cursor
         capture_screen_with_cursor(screenshot_filename)
 
@@ -787,7 +999,7 @@ async def call_gpt_4o_labeled(messages, objective, model):
         return call_gpt_4o(messages)
 
 
-def call_ollama_llava(messages):
+def call_ollama_model(messages, model_name):
     if config.verbose:
         print("[call_ollama_llava]")
     time.sleep(1)
@@ -798,6 +1010,7 @@ def call_ollama_llava(messages):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        
         # Call the function to capture the screen with the cursor
         capture_screen_with_cursor(screenshot_filename)
 
@@ -819,11 +1032,20 @@ def call_ollama_llava(messages):
         }
         messages.append(vision_message)
 
+        if config.verbose:
+            print(f"\n{ANSI_YELLOW}--- PROMPT SENT TO OLLAMA ---\n{messages}\n{ANSI_RESET}")
+
         response = model.chat(
-            model="llava",
+            model=model_name,
             messages=messages,
         )
 
+        if config.verbose:
+            print(f"\n{ANSI_GREEN}--- RESPONSE FROM OLLAMA ---\n{response}\n{ANSI_RESET}")
+
+        if not response or "message" not in response or "content" not in response["message"]:
+            raise Exception(f"Invalid response from Ollama model {model_name}: {response}")
+
         # Important: Remove the image path from the message history.
         # Ollama will attempt to load each image reference and will
         # eventually timeout.
@@ -847,8 +1069,7 @@ def call_ollama_llava(messages):
 
     except ollama.ResponseError as e:
         print(
-            f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_RED}[Operate] Couldn't connect to Ollama. With Ollama installed, run `ollama pull llava` then `ollama serve`{ANSI_RESET}",
-            e,
+            f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_RED}[Operate] Couldn't connect to Ollama. With Ollama installed, run `ollama pull {model_name}` then `ollama serve` {e}{ANSI_RESET}"
         )
 
     except Exception as e:
@@ -879,6 +1100,7 @@ async def call_claude_3_with_ocr(messages, objective, model):
             os.makedirs(screenshots_dir)
 
         screenshot_filename = os.path.join(screenshots_dir, "screenshot.png")
+        
         capture_screen_with_cursor(screenshot_filename)
 
         # downsize screenshot due to 5MB size limit
diff --git a/operate/models/model_configs.py b/operate/models/model_configs.py
new file mode 100644
index 00000000..e86f7125
--- /dev/null
+++ b/operate/models/model_configs.py
@@ -0,0 +1,48 @@
+# operate/models/model_configs.py
+
+# A centralized registry for all supported models.
+# This file simplifies adding, removing, and managing models across the application.
+#
+# Each model is defined with the following properties:
+# - 'api_key': The environment variable for the required API key.
+# - 'provider': The service provider (e.g., 'openai', 'google', 'ollama').
+# - 'display_name': The name shown in the interactive model selection menu.
+#
+# This centralized approach avoids hardcoding model names and their configurations
+# in multiple places, making the codebase cleaner and more maintainable.
+
+MODELS = {
+    # OpenAI Models
+    "gpt-4o": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4o (Default)"},
+    "gpt-4-with-ocr": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4 with OCR"},
+    "gpt-4.1": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4.1"},
+    "gpt-4.1-mini": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4.1 mini"},
+    "gpt-4.1-nano": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4.1 nano"},
+    "o1-with-ocr": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI o1 with OCR"},
+    "o3": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI o3"},
+    "o4-mini": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI o4-mini"},
+    "gpt-4-with-som": {"api_key": "OPENAI_API_KEY", "provider": "openai", "display_name": "OpenAI GPT-4 with Set-of-Mark Prompting"},
+
+    # Google Models
+    "gemini-1.5-pro-latest": {"api_key": "GOOGLE_API_KEY", "provider": "google", "display_name": "Google Gemini 1.5 Pro (latest)"},
+    "gemini-2.5-pro": {"api_key": "GOOGLE_API_KEY", "provider": "google", "display_name": "Google Gemini 2.5 Pro"},
+    "gemini-2.5-flash": {"api_key": "GOOGLE_API_KEY", "provider": "google", "display_name": "Google Gemini 2.5 Flash"},
+
+    # Anthropic Models
+    "claude-3": {"api_key": "ANTHROPIC_API_KEY", "provider": "anthropic", "display_name": "Anthropic Claude 3"},
+
+    # Qwen Models
+    "qwen-vl": {"api_key": "QWEN_API_KEY", "provider": "qwen", "display_name": "Qwen-VL"},
+
+    # Ollama Models
+    "llava": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "LLaVa (via Ollama)"},
+    "gemma3n": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Gemma 3n (via Ollama)"},
+    "gemma3n:e2b": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Gemma 3n:e2b (via Ollama)"},
+    "gemma3n:e4b": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Gemma 3n:e4b (via Ollama)"},
+    "gemma3:12b": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Gemma 3:12b (via Ollama)"},
+    "gemma3:4b": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Gemma 3:4b (via Ollama)"},
+    "qwen2.5vl:3b": {"api_key": "OLLAMA_HOST", "provider": "ollama", "display_name": "Qwen 2.5 VL 3B (via Ollama)"},
+
+    # OpenRouter Models
+    "openrouter": {"api_key": "OPENROUTER_API_KEY", "provider": "openrouter_internal", "display_name": "OpenRouter (Select Model)"}
+}
\ No newline at end of file
diff --git a/operate/models/prompts.py b/operate/models/prompts.py
index 8cea8f3e..940a8381 100644
--- a/operate/models/prompts.py
+++ b/operate/models/prompts.py
@@ -136,7 +136,7 @@
 
 You have 4 possible operation actions available to you. The `pyautogui` library will be used to execute your decision. Your output will be used in a `json.loads` loads statement.
 
-1. click - Move mouse and click - Look for text to click. Try to find relevant text to click, but if there's nothing relevant enough you can return `"nothing to click"` for the text value and we'll try a different method.
+1. click - Move mouse and click - Look for text to click. Try to find relevant text to click, but if there's nothing relevant enough you can return `"nothing to click"` for the text value and we'll try a different method. If you need to move the mouse to a specific visual element without clicking, use the `click` operation with the `text` of the element. The system will attempt to find the coordinates for you.
 ```
 [{{ "thought": "write a thought here", "operation": "click", "text": "The text in the button or link to click" }}]  
 ```
@@ -207,11 +207,17 @@
 Action:"""
 
 
-def get_system_prompt(model, objective):
+def get_system_prompt(model, objective, custom_system_prompt=None):
     """
     Format the vision prompt more efficiently and print the name of the prompt used
     """
 
+    if custom_system_prompt:
+        return custom_system_prompt
+
+    if custom_system_prompt:
+        return custom_system_prompt
+
     if platform.system() == "Darwin":
         cmd_string = "\"command\""
         os_search_str = "[\"command\", \"space\"]"
@@ -232,7 +238,7 @@ def get_system_prompt(model, objective):
             os_search_str=os_search_str,
             operating_system=operating_system,
         )
-    elif model == "gpt-4-with-ocr" or model == "gpt-4.1-with-ocr" or model == "o1-with-ocr" or model == "claude-3" or model == "qwen-vl":
+    elif model == "gpt-4-with-ocr" or model == "gpt-4.1-with-ocr" or model == "o1-with-ocr" or model == "claude-3" or model == "qwen-vl" or model.startswith("gemini"):
 
         prompt = SYSTEM_PROMPT_OCR.format(
             objective=objective,
diff --git a/operate/operate.py b/operate/operate.py
index c63d9851..63aaf2b3 100644
--- a/operate/operate.py
+++ b/operate/operate.py
@@ -2,7 +2,7 @@
 import os
 import time
 import asyncio
-from prompt_toolkit.shortcuts import message_dialog
+from prompt_toolkit.shortcuts import message_dialog, radiolist_dialog, input_dialog
 from prompt_toolkit import prompt
 from operate.exceptions import ModelNotRecognizedException
 import platform
@@ -21,6 +21,7 @@
     ANSI_BRIGHT_MAGENTA,
     ANSI_BLUE,
     style,
+    strip_ansi_codes,
 )
 from operate.utils.operating_system import OperatingSystem
 from operate.models.apis import get_next_action
@@ -30,6 +31,87 @@
 operating_system = OperatingSystem()
 
 
+from operate.models.model_configs import MODELS
+
+def display_welcome_message():
+    welcome_message = """
+Welcome to Self-Operating Computer!
+
+This tool allows multimodal models to operate a computer.
+It uses screen vision and decides on mouse/keyboard actions.
+
+Let's get started!
+"""
+    print(welcome_message)
+
+
+def select_openrouter_model_interactively():
+    text_content = f"""{ANSI_GREEN}Please enter the full OpenRouter model name.{ANSI_RESET}
+{ANSI_YELLOW}Ensure the model supports both image and text input modalities.{ANSI_RESET}
+{ANSI_YELLOW}You can find a list of suitable models here: https://openrouter.ai/models?fmt=cards&input_modalities=image%2Ctext{ANSI_RESET}
+{ANSI_YELLOW}Examples: google/gemini-2.0-flash-001, openai/gpt-4o, anthropic/claude-3-opus{ANSI_RESET}"""
+    model_name = input_dialog(
+        title="OpenRouter Model Selection",
+        text=strip_ansi_codes(text_content),
+    ).run()
+    if model_name is None:
+        sys.exit("OpenRouter model selection cancelled. Exiting.")
+    return model_name
+
+def select_model_interactively():
+    print("Attempting to display model selection dialog...")
+    models = [(name, config["display_name"]) for name, config in MODELS.items()]
+    
+    selected_model = radiolist_dialog(
+        title="Model Selection",
+        text="Please select a model to use:",
+        values=models,
+    ).run()
+    
+    if selected_model == "openrouter":
+        selected_model = select_openrouter_model_interactively()
+    
+    if selected_model is None:
+        print("Dialog was cancelled or failed to display.")
+        
+    return selected_model
+
+
+def get_custom_system_prompt():
+    if os.getenv("CUSTOM_SYSTEM_PROMPT"): # If env variable exists, don't show the screen
+        return os.getenv("CUSTOM_SYSTEM_PROMPT")
+
+    system_prompt_options = [
+        ("none", "No custom system prompt (use default model prompt)"),
+        ("file", "Load from a text file"),
+        ("env", "Load from environment variable (CUSTOM_SYSTEM_PROMPT)"),
+    ]
+
+    selected_option = radiolist_dialog(
+        title="Custom System Prompt",
+        text="""
+How would you like to provide a custom system prompt?
+
+- 'No custom system prompt': Use the default prompt for the selected model.
+- 'Load from a text file': Specify a path to a .txt file containing your prompt.
+- 'Load from environment variable': Use the value of the CUSTOM_SYSTEM_PROMPT environment variable.
+""",
+        values=system_prompt_options,
+    ).run()
+
+    if selected_option == "file":
+        file_path = prompt("Enter the path to the system prompt file:")
+        try:
+            with open(file_path, "r") as f:
+                return f.read()
+        except FileNotFoundError:
+            print(f"{ANSI_RED}Error: File not found at {file_path}{ANSI_RESET}")
+            return None
+    elif selected_option == "env":
+        return os.getenv("CUSTOM_SYSTEM_PROMPT")
+    return None
+
+
 def main(model, terminal_prompt, voice_mode=False, verbose_mode=False):
     """
     Main function for the Self-Operating Computer.
@@ -47,8 +129,25 @@ def main(model, terminal_prompt, voice_mode=False, verbose_mode=False):
     # Initialize `WhisperMic`, if `voice_mode` is True
 
     config.verbose = verbose_mode
+
+    display_welcome_message()
+
+    if not model:
+        openrouter_model_env = os.getenv("OPENROUTER_MODEL")
+        if openrouter_model_env:
+            model = f"openrouter_internal_{openrouter_model_env}"
+        else:
+            model = select_model_interactively()
+            if not model:  # User cancelled model selection
+                sys.exit("Model selection cancelled. Exiting.")
+            # If the selected model is from OpenRouter, add the internal prefix
+            if model and MODELS.get(model, {}).get("provider") == "openrouter":
+                model = f"openrouter_internal_{model}"
+
     config.validation(model, voice_mode)
 
+    custom_system_prompt = get_custom_system_prompt()
+
     if voice_mode:
         try:
             from whisper_mic import WhisperMic
@@ -61,17 +160,6 @@ def main(model, terminal_prompt, voice_mode=False, verbose_mode=False):
             )
             sys.exit(1)
 
-    # Skip message dialog if prompt was given directly
-    if not terminal_prompt:
-        message_dialog(
-            title="Self-Operating Computer",
-            text="An experimental framework to enable multimodal models to operate computers",
-            style=style,
-        ).run()
-
-    else:
-        print("Running direct prompt...")
-
     # # Clear the console
     if platform.system() == "Windows":
         os.system("cls")
@@ -96,7 +184,7 @@ def main(model, terminal_prompt, voice_mode=False, verbose_mode=False):
         print(f"{ANSI_YELLOW}[User]{ANSI_RESET}")
         objective = prompt(style=style)
 
-    system_prompt = get_system_prompt(model, objective)
+    system_prompt = get_system_prompt(model, objective, custom_system_prompt)
     system_message = {"role": "system", "content": system_prompt}
     messages = [system_message]
 
@@ -113,7 +201,18 @@ def main(model, terminal_prompt, voice_mode=False, verbose_mode=False):
             )
 
             stop = operate(operations, model)
-            if stop:
+            if stop == "done":
+                # Task completed, prompt for next objective
+                print(f"[{ANSI_GREEN}Self-Operating Computer {ANSI_RESET}|{ANSI_BRIGHT_MAGENTA} {model}{ANSI_RESET}]\n{USER_QUESTION}")
+                print(f"{ANSI_YELLOW}[User]{ANSI_RESET}")
+                objective = prompt(style=style)
+                system_prompt = get_system_prompt(model, objective, custom_system_prompt)
+                system_message = {"role": "system", "content": system_prompt}
+                messages = [system_message] # Reset messages for new objective
+                loop_count = 0 # Reset loop count for new objective
+                session_id = None # Reset session ID for new objective
+                continue # Continue to the next iteration of the main loop
+            elif stop:
                 break
 
             loop_count += 1
@@ -162,13 +261,11 @@ def operate(operations, model):
             operating_system.mouse(click_detail)
         elif operate_type == "done":
             summary = operation.get("summary")
-
             print(
                 f"[{ANSI_GREEN}Self-Operating Computer {ANSI_RESET}|{ANSI_BRIGHT_MAGENTA} {model}{ANSI_RESET}]"
             )
-            print(f"{ANSI_BLUE}Objective Complete: {ANSI_RESET}{summary}\n")
-            return True
-
+            print(f"{ANSI_BLUE}Objective Complete: {ANSI_RESET}{summary}" + "\n")
+            return "done"
         else:
             print(
                 f"{ANSI_GREEN}[Self-Operating Computer]{ANSI_RED}[Error] unknown operation response :({ANSI_RESET}"
diff --git a/operate/utils/ocr.py b/operate/utils/ocr.py
index 937511b0..54b12607 100644
--- a/operate/utils/ocr.py
+++ b/operate/utils/ocr.py
@@ -42,7 +42,7 @@ def get_text_element(result, search_text, image_path):
             # Draw bounding box in blue
             draw.polygon([tuple(point) for point in box], outline="blue")
 
-        if search_text in text:
+        if search_text.lower().strip() in text.lower().strip():
             found_index = index
             if config.verbose:
                 print("[get_text_element][loop] found search_text, index:", index)
@@ -59,8 +59,9 @@ def get_text_element(result, search_text, image_path):
             print("[get_text_element] OCR image saved at:", ocr_image_path)
 
         return found_index
-
-    raise Exception("The text element was not found in the image")
+    if config.verbose:
+        print(f"[get_text_element] Text '{search_text}' not found in OCR results.")
+    return None
 
 
 def get_text_coordinates(result, index, image_path):
diff --git a/operate/utils/style.py b/operate/utils/style.py
index 2948582f..353d231f 100644
--- a/operate/utils/style.py
+++ b/operate/utils/style.py
@@ -1,6 +1,7 @@
 import sys
 import platform
 import os
+import re
 from prompt_toolkit.styles import Style as PromptStyle
 
 
@@ -34,3 +35,9 @@ def supports_ansi():
 ANSI_YELLOW = "\033[33m" if supports_ansi() else ""  # Standard yellow text
 ANSI_RED = "\033[31m" if supports_ansi() else ""
 ANSI_BRIGHT_MAGENTA = "\033[95m" if supports_ansi() else ""  # Bright magenta text
+
+def strip_ansi_codes(s):
+    """
+    Strips ANSI escape codes from a string.
+    """
+    return re.sub(r'\x1b\[[0-9;]*m', '', s)
diff --git a/readme/choose-model.png b/readme/choose-model.png
new file mode 100644
index 00000000..af04b276
Binary files /dev/null and b/readme/choose-model.png differ
diff --git a/readme/model-selction.png b/readme/model-selction.png
new file mode 100644
index 00000000..eff4d992
Binary files /dev/null and b/readme/model-selction.png differ
diff --git a/readme/prompt1.png b/readme/prompt1.png
new file mode 100644
index 00000000..79b18c4e
Binary files /dev/null and b/readme/prompt1.png differ
diff --git a/readme/system-parameter-1.png b/readme/system-parameter-1.png
new file mode 100644
index 00000000..b9b1d266
Binary files /dev/null and b/readme/system-parameter-1.png differ
diff --git a/readme/system-parameter-2.png b/readme/system-parameter-2.png
new file mode 100644
index 00000000..56a1e56c
Binary files /dev/null and b/readme/system-parameter-2.png differ
diff --git a/requirements.txt b/requirements.txt
index c7a646be..5a1fa3d3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,6 @@
 annotated-types==0.6.0
 anyio==3.7.1
-certifi==2023.7.22
+certifi==2025.6.15
 charset-normalizer==3.3.2
 colorama==0.4.6
 contourpy==1.2.0
diff --git a/sample-system-prompt.md b/sample-system-prompt.md
new file mode 100644
index 00000000..aef88803
--- /dev/null
+++ b/sample-system-prompt.md
@@ -0,0 +1 @@
+You are a helpful assistant that can perform tasks on a computer. You can execute commands, answer questions, and assist with various tasks. Your goal is to help the user efficiently and effectively.
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 6cdf6163..02bb7df1 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,8 @@
+import os
 from setuptools import setup, find_packages
 
 # Read the contents of your requirements.txt file
-with open("requirements.txt") as f:
+with open(os.path.join(os.path.dirname(__file__), "requirements.txt")) as f:
     required = f.read().splitlines()
 
 # Read the contents of your README.md file for the project description
@@ -9,10 +10,66 @@
     long_description = readme_file.read()
 
 setup(
-    name="self-operating-computer",
-    version="1.5.8",
+    name="self-ai-operating-computer",
+    version="2.0.16",
     packages=find_packages(),
-    install_requires=required,  # Add dependencies here
+    install_requires=[
+        "annotated-types==0.6.0",
+        "anyio==3.7.1",
+        "certifi==2025.6.15",
+        "charset-normalizer==3.3.2",
+        "colorama==0.4.6",
+        "contourpy==1.2.0",
+        "cycler==0.12.1",
+        "distro==1.8.0",
+        "EasyProcess==1.1",
+        "entrypoint2==1.1",
+        "exceptiongroup==1.1.3",
+        "fonttools==4.44.0",
+        "h11==0.14.0",
+        "httpcore==1.0.2",
+        "httpx>=0.25.2",
+        "idna==3.4",
+        "importlib-resources==6.1.1",
+        "kiwisolver==1.4.5",
+        "matplotlib==3.8.1",
+        "MouseInfo==0.1.3",
+        "mss==9.0.1",
+        "numpy==1.26.1",
+        "openai==1.2.3",
+        "packaging>=23.2,<24.0",
+        "Pillow==10.1.0",
+        "prompt-toolkit==3.0.39",
+        "PyAutoGUI==0.9.54",
+        "pydantic==2.4.2",
+        "pydantic_core==2.10.1",
+        "PyGetWindow==0.0.9",
+        "PyMsgBox==1.0.9",
+        "pyparsing==3.1.1",
+        "pyperclip==1.8.2",
+        "PyRect==0.2.0",
+        "pyscreenshot==3.1",
+        "PyScreeze==0.1.29",
+        "python3-xlib==0.15",
+        "python-dateutil==2.8.2",
+        "python-dotenv==1.0.0",
+        "pytweening==1.0.7",
+        "requests==2.31.0",
+        "rubicon-objc==0.4.7",
+        "six==1.16.0",
+        "sniffio==1.3.0",
+        "tqdm==4.66.1",
+        "typing_extensions==4.8.0",
+        "urllib3==2.0.7",
+        "wcwidth==0.2.9",
+        "zipp==3.17.0",
+        "google-generativeai==0.3.0",
+        "aiohttp==3.9.1",
+        "ultralytics==8.0.227",
+        "easyocr==1.7.1",
+        "ollama==0.1.6",
+        "anthropic",
+    ],
     entry_points={
         "console_scripts": [
             "operate=operate.main:main_entry",