diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000..c5ae7c3
Binary files /dev/null and b/.DS_Store differ
diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..5269548
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,3 @@
+[flake8]
+extend-ignore = E203, E266, E501, W503, F403, F401, F841, F405, F541
+max-line-length = 120
\ No newline at end of file
diff --git a/.github/workflows/master_proback.yml b/.github/workflows/master_proback.yml
new file mode 100644
index 0000000..43f58d6
--- /dev/null
+++ b/.github/workflows/master_proback.yml
@@ -0,0 +1,78 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+# More info on Python, GitHub Actions, and Azure App Service: https://aka.ms/python-webapps-actions
+
+name: Build and deploy Python app to Azure Web App - proback
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python version
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Create and start virtual environment
+        run: |
+          python -m venv venv
+          source venv/bin/activate
+      
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+        
+      # Optional: Add step to run tests here (PyTest, Django test suites, etc.)
+
+      - name: Zip artifact for deployment
+        run: zip release.zip ./* -r
+
+      - name: Upload artifact for deployment jobs
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-app
+          path: |
+            release.zip
+            !venv/
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: 'Production'
+      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
+    permissions:
+      id-token: write #This is required for requesting the JWT
+
+    steps:
+      - name: Download artifact from build job
+        uses: actions/download-artifact@v4
+        with:
+          name: python-app
+
+      - name: Unzip artifact for deployment
+        run: unzip release.zip
+
+      
+      - name: Login to Azure
+        uses: azure/login@v2
+        with:
+          client-id: ${{ secrets.AZUREAPPSERVICE_CLIENTID_03FB85159B9A4E78AACF5C9E49520FA7 }}
+          tenant-id: ${{ secrets.AZUREAPPSERVICE_TENANTID_CDBEEAED51A249279383A6E8687EC9C2 }}
+          subscription-id: ${{ secrets.AZUREAPPSERVICE_SUBSCRIPTIONID_8376CC7B1D6F40DAACC0EE4E277694F7 }}
+
+      - name: 'Deploy to Azure Web App'
+        uses: azure/webapps-deploy@v3
+        id: deploy-to-webapp
+        with:
+          app-name: 'proback'
+          slot-name: 'Production'
+          
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 3b75b79..48a83d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,5 @@ htmlcov/
 .tox/
 docs/_build/
 *.json
-firebase-credentials.json
\ No newline at end of file
+firebase-credentials.json
+*.log
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..8c252be
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,26 @@
+files: ^server/.*\.py$
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        args: ["--line-length=120"]
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        args: ["--profile", "black"]
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+
+default_stages: [pre-commit, pre-push]
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..1dadd5a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,61 @@
+# ProBack Backend
+
+## Installation
+
+### Prerequisites
+
+- Python 3.12
+- MongoDB Instance
+- Firebase Project with service account credentials
+
+### Steps
+
+1. **Clone the Repository**
+
+   ```bash
+   git clone <repo_url>
+   cd proback/server
+   ```
+
+2. **Create Virtual Environment**
+
+   ```bash
+   python -m venv venv
+   source venv/bin/activate
+   ```
+
+3. **Install Dependencies**
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Configure Environment Variables**
+
+   Create a `.env` file in the `server` directory with the following:
+
+   ```env
+   MONGO_URI=your_mongodb_uri
+   SECRET_KEY=your_secret_key
+   CLAUDE_API_KEY=your_claude_api_key
+   OPENAI_API_KEY=your_openai_api_key
+   ```
+
+5. **Firebase Setup**
+
+   Place your `firebase-credentials.json` in the project root as specified in `config.py`.
+
+## Configuration
+
+The backend configuration is managed through the `Config` class in `server/app/config.py`. It loads environment variables and sets default values for various settings.
+
+### CORS
+
+Configure allowed origins in the `CORS_ORIGINS` list within `config.py`.
+
+
+### Setup Pre-commit
+
+1. change directory to server and do `pip install -r requirements.txt`
+2. now run `pre-commit install` to install precommit hooks
+3. now you can run `pre-commit run --all-files` to run precommit hooks on all files if you want to run on specific file then run `pre-commit run <file_name>`
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..c0476d8
Binary files /dev/null and b/requirements.txt differ
diff --git a/server/.DS_Store b/server/.DS_Store
new file mode 100644
index 0000000..36475a8
Binary files /dev/null and b/server/.DS_Store differ
diff --git a/server/app/api/__init__.py b/server/__init__.py
similarity index 100%
rename from server/app/api/__init__.py
rename to server/__init__.py
diff --git a/server/app/.DS_Store b/server/app/.DS_Store
new file mode 100644
index 0000000..459c3a8
Binary files /dev/null and b/server/app/.DS_Store differ
diff --git a/server/app/__init__.py b/server/app/__init__.py
index fca109f..2524edd 100644
--- a/server/app/__init__.py
+++ b/server/app/__init__.py
@@ -1,29 +1,59 @@
-from flask import Flask
+import logging
+
+import certifi
+import mongoengine
+from flask import Blueprint, Flask
 from flask_cors import CORS
-from .config import Config
-from .api.auth_routes import auth_bp
+
+from .api_views.ai_agent_variant_view import agent_variant_bp
+from .api_views.ai_agent_view import ai_agent_bp
+from .api_views.auth_view import auth_bp
+from .api_views.config_view import config_bp
+from .api_views.dataset_view import dataset_bp
+from .api_views.evaluation_view import evaluation_bp
+from .api_views.main_view import main_bp
+from .api_views.project_view import project_bp
+from .config import Config, Logging
+
+# Initialize logging once
+Logging.initialize(log_level=logging.INFO, log_file="application.log")
+
+
+def register_api_blueprints(app):
+    api_bp = Blueprint("api", __name__, url_prefix="/api")
+    api_bp.register_blueprint(config_bp)
+    api_bp.register_blueprint(auth_bp)
+    api_bp.register_blueprint(project_bp)
+    api_bp.register_blueprint(evaluation_bp)
+    api_bp.register_blueprint(dataset_bp)
+    api_bp.register_blueprint(ai_agent_bp)
+    api_bp.register_blueprint(agent_variant_bp)
+    app.register_blueprint(api_bp)
+    app.register_blueprint(main_bp)
+
 
 def create_app(config_class=Config):
-    app = Flask(__name__, 
-                static_folder='../../src/static',  # Points to frontend files
-                template_folder='../../src/templates')  # Points to frontend files
-    
-    # Load config
+    """
+    Create a Flask app with the given configuration.
+    """
+    app = Flask(__name__, static_folder="../../src/static", template_folder="../../src/templates")
+
+    # mongoengine
+    mongoengine.connect(
+        host=config_class.MONGO_URI,
+        ssl=True,
+        tlscafile=certifi.where(),
+    )
+
+    # config
     app.config.from_object(config_class)
-    
-    # Initialize CORS
-    CORS(app)
 
-    # Register blueprints
-    from .api.character_routes import character_bp
-    from .api.dataset_routes import dataset_bp
-    from .api.evaluation_routes import evaluation_bp
-    from .api.main import main_bp
+    # make url_map not strict
+    app.url_map.strict_slashes = False
 
-    app.register_blueprint(main_bp)
-    app.register_blueprint(character_bp, url_prefix='/api')
-    app.register_blueprint(dataset_bp, url_prefix='/api')
-    app.register_blueprint(evaluation_bp, url_prefix='/api')
-    app.register_blueprint(auth_bp, url_prefix='/api')
+    # cors
+    CORS(app)
 
+    # register api blueprints
+    register_api_blueprints(app)
     return app
diff --git a/server/app/api/auth_routes.py b/server/app/api/auth_routes.py
deleted file mode 100644
index acd05a6..0000000
--- a/server/app/api/auth_routes.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from flask import Blueprint, request, jsonify, session
-from ..auth.handlers import AuthHandler
-
-auth_bp = Blueprint('auth', __name__)
-
-@auth_bp.route('/auth/verify', methods=['POST'])
-def verify_token():
-    """Verify Firebase token and create session"""
-    data = request.get_json()
-    id_token = data.get('idToken')
-    
-    if not id_token:
-        return jsonify({'error': 'No token provided'}), 400
-
-    decoded_token = AuthHandler.verify_firebase_token(id_token)
-    if not decoded_token:
-        return jsonify({'error': 'Invalid token'}), 401
-
-    AuthHandler.create_session(decoded_token)
-    return jsonify({'success': True, 'user': session['user']})
-
-@auth_bp.route('/auth/logout', methods=['POST'])
-def logout():
-    """Clear user session"""
-    AuthHandler.clear_session()
-    return jsonify({'success': True})
-
-@auth_bp.route('/auth/session')
-def get_session():
-    """Get current session info"""
-    user = session.get('user')
-    if user:
-        return jsonify({'user': user})
-    return jsonify({'user': None}), 401
\ No newline at end of file
diff --git a/server/app/api/character_routes.py b/server/app/api/character_routes.py
deleted file mode 100644
index ba3ed24..0000000
--- a/server/app/api/character_routes.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from flask import Blueprint, request, jsonify, session
-from ..core.characters import (
-    get_all_characters, save_character, delete_character, 
-    get_character, update_character
-)
-from ..auth.decorators import login_required
-
-character_bp = Blueprint('characters', __name__)
-
-@character_bp.route('/characters', methods=['GET'])
-@login_required
-def get_characters():
-    user_id = session['user']['uid']
-    return jsonify(get_all_characters(user_id))
-
-@character_bp.route('/characters', methods=['POST'])
-@login_required
-def create_character():
-    data = request.json
-    user_id = session['user']['uid']
-    character_id = save_character(
-        name=data['name'],
-        backstory=data['backstory'],
-        model=data['model'],
-        temperature=float(data['temperature']),
-        max_tokens=int(data['max_tokens']),
-        user_id=user_id
-    )
-    return jsonify({"message": f"Character '{data['name']}' created successfully", "id": character_id}), 201
-
-@character_bp.route('/characters/<character_id>', methods=['PUT'])
-@login_required
-def update_character_route(character_id):
-    data = request.json
-    user_id = session['user']['uid']
-    if update_character(
-        character_id=character_id,
-        name=data['name'],
-        backstory=data['backstory'],
-        model=data['model'],
-        temperature=float(data['temperature']),
-        max_tokens=int(data['max_tokens']),
-        user_id=user_id
-    ):
-        return jsonify({"message": f"Character '{data['name']}' updated successfully"})
-    return jsonify({"message": "Character not found"}), 404
-
-@character_bp.route('/characters/<character_id>', methods=['DELETE'])
-@login_required
-def remove_character(character_id):
-    user_id = session['user']['uid']
-    if delete_character(character_id, user_id):
-        return jsonify({"message": "Character deleted successfully"})
-    return jsonify({"message": "Character not found"}), 404
\ No newline at end of file
diff --git a/server/app/api/dataset_routes.py b/server/app/api/dataset_routes.py
deleted file mode 100644
index 1f821fc..0000000
--- a/server/app/api/dataset_routes.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from flask import Blueprint, request, jsonify, session
-from ..core.datasets import (
-    get_all_datasets, save_dataset, delete_dataset,
-    get_dataset, update_dataset
-)
-from ..auth.decorators import login_required
-
-dataset_bp = Blueprint('datasets', __name__)
-
-@dataset_bp.route('/datasets', methods=['GET'])
-@login_required
-def get_datasets():
-    user_id = session['user']['uid']
-    return jsonify(get_all_datasets(user_id))
-
-@dataset_bp.route('/datasets', methods=['POST'])
-@login_required
-def create_dataset():
-    data = request.json
-    user_id = session['user']['uid']
-    dataset_id = save_dataset(
-        name=data['name'],
-        metric_name=data['metric_name'],
-        metric_description=data['metric_description'],
-        questions=data['questions'],
-        user_id=user_id
-    )
-    return jsonify({"message": f"Dataset '{data['name']}' created successfully", "id": dataset_id}), 201
-
-@dataset_bp.route('/datasets/<dataset_id>', methods=['PUT'])
-@login_required
-def update_dataset_route(dataset_id):
-    data = request.json
-    user_id = session['user']['uid']
-    if update_dataset(
-        dataset_id=dataset_id,
-        name=data['name'],
-        metric_name=data['metric_name'],
-        metric_description=data['metric_description'],
-        questions=data['questions'],
-        user_id=user_id
-    ):
-        return jsonify({"message": "Dataset updated successfully"})
-    return jsonify({"message": "Dataset not found"}), 404
-
-@dataset_bp.route('/datasets/<dataset_id>', methods=['DELETE'])
-@login_required
-def remove_dataset(dataset_id):
-    user_id = session['user']['uid']
-    if delete_dataset(dataset_id, user_id):
-        return jsonify({"message": "Dataset deleted successfully"})
-    return jsonify({"message": "Dataset not found"}), 404
\ No newline at end of file
diff --git a/server/app/api/evaluation_routes.py b/server/app/api/evaluation_routes.py
deleted file mode 100644
index 50e7e03..0000000
--- a/server/app/api/evaluation_routes.py
+++ /dev/null
@@ -1,69 +0,0 @@
-from flask import Blueprint, request, jsonify, session
-from ..core.characters import get_character
-from ..core.datasets import get_dataset
-from ..core.models import Character, Evaluator
-from ..auth.decorators import login_required
-
-evaluation_bp = Blueprint('evaluation', __name__)
-
-@evaluation_bp.route('/evaluate', methods=['POST'])
-@login_required
-def evaluate():
-    data = request.json
-    user_id = session['user']['uid']
-    character_id = data['character']
-    dataset_id = data['dataset']
-    
-    char_data = get_character(character_id, user_id)
-    if not char_data:
-        return jsonify({"message": "Character not found"}), 404
-    
-    dataset = get_dataset(dataset_id, user_id)
-    if not dataset:
-        return jsonify({"message": "Dataset not found"}), 404
-    
-    character = Character(char_data["name"], char_data["backstory"], "User")
-    
-    evaluator = Evaluator(
-        metric={"name": dataset['metric_name'], "description": dataset['metric_description']},
-        character=character,
-        n=len(dataset['questions']),
-        model_type="claude" if char_data["model"].startswith("claude") else "openai"
-    )
-    
-    results = evaluator.test_model(dataset['questions'])
-    
-    return jsonify({
-        "results": [
-            {"question": q, "response": r, "score": s}
-            for q, r, s in results
-        ],
-        "total_score": sum(score for _, _, score in results),
-        "max_score": len(results)
-    })
-
-@evaluation_bp.route('/generate_questions', methods=['POST'])
-@login_required
-def generate_questions():
-    data = request.json
-    user_id = session['user']['uid']
-    character_id = data['character']
-    metric_name = data['metric_name']
-    metric_description = data['metric_description']
-    num_questions = int(data['num_questions'])
-    
-    char_data = get_character(character_id, user_id)
-    if not char_data:
-        return jsonify({"message": "Character not found"}), 404
-    
-    character = Character(char_data["name"], char_data["backstory"], "User")
-    
-    evaluator = Evaluator(
-        metric={"name": metric_name, "description": metric_description},
-        character=character,
-        n=num_questions,
-        model_type="claude" if char_data["model"].startswith("claude") else "openai"
-    )
-    evaluator.generate_questions()
-    
-    return jsonify({"questions": evaluator.questions})
\ No newline at end of file
diff --git a/server/app/api/main.py b/server/app/api/main.py
deleted file mode 100644
index 94bc9c3..0000000
--- a/server/app/api/main.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from flask import Blueprint, render_template, session, redirect
-
-main_bp = Blueprint('main', __name__)
-
-@main_bp.route('/')
-def index():
-    if 'user' not in session:
-        return redirect('/login')
-    return render_template('index.html')
-
-@main_bp.route('/login')
-def login():
-    if 'user' in session:
-        return redirect('/')
-    return render_template('login.html')
\ No newline at end of file
diff --git a/server/app/api_views/__init__.py b/server/app/api_views/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/server/app/api_views/ai_agent_variant_view.py b/server/app/api_views/ai_agent_variant_view.py
new file mode 100644
index 0000000..1cf3ec4
--- /dev/null
+++ b/server/app/api_views/ai_agent_variant_view.py
@@ -0,0 +1,110 @@
+from bson import ObjectId
+from flask import Blueprint, jsonify, request
+from flask.views import MethodView
+
+from ..auth.decorators import login_required
+from ..config import Logging
+from ..models import AIAgentVariant, Project
+from ..serializers import AIAgentVariantSerializer
+
+logger = Logging.get_logger(__name__)
+agent_variant_bp = Blueprint("agent_variant", __name__, url_prefix="/projects/<project_id>/agents/<agent_id>/variants")
+
+
+class VariantListAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id, agent_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+            serialized = AIAgentVariantSerializer(many=True).dump(agent.variants)
+            logger.info("Successfully fetched variants")
+            return jsonify({"message": "Successfully fetched variants", "data": serialized}), 200
+        except Exception as e:
+            logger.error(f"Error fetching variants: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def post(self, project_id, agent_id):
+        try:
+            data = request.json
+            variant_name = data.get("name")
+            variables = data.get("variables")
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+            if not set(variables.keys()).issubset(set(agent.included_variables)):
+                return jsonify({"error": "Variables not included in the agent"}), 400
+            new_variant = AIAgentVariant(name=variant_name, variables=variables, is_alive=True)
+            agent.variants.append(new_variant)
+            project.save()
+            logger.info("Variant created successfully")
+            return jsonify({"message": "Variant created successfully"}), 201
+        except Exception as e:
+            logger.error(f"Error creating variant: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+class VariantDetailAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id, agent_id, variant_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+            variant = next((v for v in agent.variants if v.id == ObjectId(variant_id)), None)
+            if not variant:
+                return jsonify({"error": "Variant not found"}), 404
+            serialized = AIAgentVariantSerializer().dump(variant)
+            logger.info("Successfully fetched variant")
+            return jsonify({"message": "Variant fetched successfully", "data": serialized}), 200
+        except Exception as e:
+            logger.error(f"Error fetching variant: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def put(self, project_id, agent_id, variant_id):
+        try:
+            data = request.json
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+            variant = next((v for v in agent.variants if v.id == ObjectId(variant_id)), None)
+            if not variant:
+                return jsonify({"error": "Variant not found"}), 404
+            variant.name = data.get("name", variant.name)
+            variant.variables = data.get("variables", variant.variables)
+            project.save()
+            logger.info("Variant updated successfully")
+            return jsonify({"message": "Variant updated successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error updating variant: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def delete(self, project_id, agent_id, variant_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+            variant = next((v for v in agent.variants if v.id == ObjectId(variant_id)), None)
+            if not variant:
+                return jsonify({"error": "Variant not found"}), 404
+            agent.variants.remove(variant)
+            project.save()
+            logger.info("Variant deleted successfully")
+            return jsonify({"message": "Variant deleted successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error deleting variant: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+agent_variant_bp.add_url_rule("/", view_func=VariantListAPI.as_view("variant_list_api"), methods=["GET", "POST"])
+agent_variant_bp.add_url_rule(
+    "/<variant_id>", view_func=VariantDetailAPI.as_view("variant_detail_api"), methods=["GET", "PUT", "DELETE"]
+)
diff --git a/server/app/api_views/ai_agent_view.py b/server/app/api_views/ai_agent_view.py
new file mode 100644
index 0000000..58b7913
--- /dev/null
+++ b/server/app/api_views/ai_agent_view.py
@@ -0,0 +1,144 @@
+from bson import ObjectId
+from flask import Blueprint, Response, jsonify, request, stream_with_context
+from flask.views import MethodView
+
+from ..auth.decorators import login_required
+from ..config import Config, Logging
+from ..core.services.llm_service import LLMResponseService
+from ..models import AIAgent, Project
+from ..serializers import AIAgentSerializer
+
+logger = Logging.get_logger(__name__)
+
+ai_agent_bp = Blueprint("ai_agent", __name__, url_prefix="/projects")
+
+
+class AIAgentAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id):
+        """Fetch all AI agents for a given project."""
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agents = AIAgentSerializer(many=True).dump(project.ai_agents)
+            logger.info(f"Successfully fetched AI agents for project: {project_id}")
+            return (
+                jsonify({"message": f"Successfully fetched AI agents for project: {project_id}", "data": agents}),
+                200,
+            )
+        except Exception as e:
+            logger.error(f"Error fetching AI agents: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def post(self, project_id):
+        """Create a new AI agent for a given project."""
+        try:
+            data = request.json
+            project = Project.objects.get(id=ObjectId(project_id))
+            new_agent = AIAgent(
+                name=data["name"],
+                agent_config=data["config"],
+                prompt=data["prompt"],
+                included_variables=data["included_variables"],
+                is_alive=True,
+            )
+            project.ai_agents.append(new_agent)
+            project.save()
+            logger.info("AI Agent created successfully")
+            return jsonify({"message": "AI Agent created successfully"}), 201
+        except Exception as e:
+            logger.error(f"Error creating AI agent: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+class AIAgentDetailAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id, agent_id):
+        """Retrieve details for a specific AI agent in a project."""
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if agent:
+                return jsonify(AIAgentSerializer().dump(agent)), 200
+            return jsonify({"error": "Agent not found"}), 404
+        except Exception as e:
+            logger.error(f"Error retrieving AI agent: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def put(self, project_id, agent_id):
+        """Update a specific AI agent in a project."""
+        try:
+            data = request.json
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+
+            agent.name = data.get("name", agent.name)
+            agent.agent_config = data.get("config", agent.agent_config)
+            agent.prompt = data.get("prompt", agent.prompt)
+            agent.included_variables = data.get("included_variables", agent.included_variables)
+            project.save()
+            logger.info("AI Agent updated successfully")
+            return jsonify({"message": "AI Agent updated successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error updating AI agent: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def delete(self, project_id, agent_id):
+        """Delete a specific AI agent from a project."""
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+
+            project.ai_agents.remove(agent)
+            project.save()
+            logger.info("AI Agent deleted successfully")
+            return jsonify({"message": "AI Agent deleted successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error deleting AI agent: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+class ConversationAPI(MethodView):
+    decorators = [login_required]
+
+    def post(self):
+        """Generate a conversation (with optional streaming) from the provided prompt and configuration."""
+        try:
+            data = request.json
+            config = data.get("config")
+            prompt = data.get("prompt")
+            stream = data.get("stream", True)
+            logger.info(f"Generating conversation for prompt: {prompt} with config: {config} and stream: {stream}")
+            model = config.get("model")
+            max_tokens = config.get("max_tokens") or Config.DEFAULT_MAX_TOKENS
+            temperature = config.get("temperature") or Config.DEFAULT_TEMPERATURE
+            llm_service = LLMResponseService(
+                model=model, prompt=prompt, max_tokens=max_tokens, temperature=temperature, stream=stream
+            )
+            if stream:
+                logger.info(f"Streaming conversation for prompt: {prompt}")
+                return Response(stream_with_context(llm_service.get_response()), content_type="text/event-stream")
+            else:
+                logger.info(f"Generating conversation for prompt: {prompt} without stream")
+                return jsonify(llm_service.get_response()), 200
+        except Exception as e:
+            logger.error(f"Error generating conversation: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+# Agents endpoints are nested under /projects/<project_id>/agents
+ai_agent_bp.add_url_rule(
+    "/<string:project_id>/agents/", view_func=AIAgentAPI.as_view("ai_agent_api"), methods=["GET", "POST"]
+)
+ai_agent_bp.add_url_rule(
+    "/<string:project_id>/agents/<string:agent_id>",
+    view_func=AIAgentDetailAPI.as_view("ai_agent_detail_api"),
+    methods=["GET", "PUT", "DELETE"],
+)
+
+ai_agent_bp.add_url_rule("/conversation", view_func=ConversationAPI.as_view("conversation_api"), methods=["POST"])
diff --git a/server/app/api_views/auth_view.py b/server/app/api_views/auth_view.py
new file mode 100644
index 0000000..c957c60
--- /dev/null
+++ b/server/app/api_views/auth_view.py
@@ -0,0 +1,57 @@
+from flask import Blueprint, jsonify, request, session
+from flask.views import MethodView
+
+from ..auth.handlers import AuthHandler
+from ..config import Logging
+from ..models import User
+
+logger = Logging.get_logger(__name__)
+auth_bp = Blueprint("auth", __name__, url_prefix="/auth")
+
+
+class VerifyAPI(MethodView):
+    def post(self):
+        data = request.get_json()
+        id_token = data.get("idToken")
+        if not id_token:
+            return jsonify({"error": "No token provided"}), 400
+        decoded_token = AuthHandler.verify_firebase_token(id_token)
+        if not decoded_token:
+            return jsonify({"error": "Invalid token"}), 401
+        user = User.objects.filter(firebase_uid=decoded_token.get("uid")).first()
+        if not user:
+            logger.info(f"Creating new user: {decoded_token.get('email')}")
+            user = User(
+                name=decoded_token.get("name"),
+                email=decoded_token.get("email"),
+                picture=decoded_token.get("picture"),
+                firebase_uid=decoded_token.get("uid"),
+                is_alive=True,
+            )
+            user.save()
+        if not user.is_alive:
+            logger.info(f"User account deactivated: {decoded_token.get('email')}")
+            return jsonify({"error": "User account has been deactivated"}), 401
+        logger.info(f"User logged in: {user.email}")
+        AuthHandler.create_session(decoded_token)
+        return jsonify({"success": True, "user": session["user"]})
+
+
+class LogoutAPI(MethodView):
+    def post(self):
+        logger.info(f"User logged out: {session.get('user', {}).get('email')}")
+        AuthHandler.clear_session()
+        return jsonify({"success": True})
+
+
+class SessionAPI(MethodView):
+    def get(self):
+        user = session.get("user")
+        if user:
+            return jsonify({"user": user})
+        return jsonify({"user": None}), 401
+
+
+auth_bp.add_url_rule("/verify", view_func=VerifyAPI.as_view("verify_api"), methods=["POST"])
+auth_bp.add_url_rule("/logout", view_func=LogoutAPI.as_view("logout_api"), methods=["POST"])
+auth_bp.add_url_rule("/session", view_func=SessionAPI.as_view("session_api"), methods=["GET"])
diff --git a/server/app/api_views/config_view.py b/server/app/api_views/config_view.py
new file mode 100644
index 0000000..90cd79f
--- /dev/null
+++ b/server/app/api_views/config_view.py
@@ -0,0 +1,14 @@
+from flask import Blueprint, jsonify
+from flask.views import MethodView
+
+from ..utils.model_map import LLM_MODELS
+
+
+class ConfigAPI(MethodView):
+    def get(self):
+        return jsonify(LLM_MODELS)
+
+
+config_bp = Blueprint("config", __name__, url_prefix="/config")
+config_view = ConfigAPI.as_view("config_api")
+config_bp.add_url_rule("/models", view_func=config_view, methods=["GET"])
diff --git a/server/app/api_views/dataset_view.py b/server/app/api_views/dataset_view.py
new file mode 100644
index 0000000..36913a9
--- /dev/null
+++ b/server/app/api_views/dataset_view.py
@@ -0,0 +1,157 @@
+from bson import ObjectId
+from flask import Blueprint, jsonify, request
+from flask.views import MethodView
+
+from ..auth.decorators import login_required
+from ..config import Logging
+from ..models import Dataset, Project
+from ..serializers import DatasetSerializer
+
+logger = Logging.get_logger(__name__)
+dataset_bp = Blueprint("dataset", __name__, url_prefix="/projects/<string:project_id>/datasets")
+
+
+class DatasetListAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            datasets = Dataset.objects.filter(project=project, is_alive=True)
+            serialized = DatasetSerializer(many=True).dump(datasets)
+            logger.info(f"Fetched datasets for project: {project_id}")
+            return jsonify({"message": "Successfully fetched datasets", "data": serialized}), 200
+        except Exception as e:
+            logger.error(f"Error fetching datasets: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+    def post(self, project_id):
+        try:
+            data = request.json
+            project = Project.objects.get(id=ObjectId(project_id))
+            dataset = Dataset(
+                project=project,
+                name=data["name"],
+                type=data["type"],
+                samples=data.get("samples", []),
+                is_alive=True,
+            ).save()
+            logger.info(f"Dataset '{data['name']}' created successfully")
+            return jsonify({"message": f"Dataset '{data['name']}' created successfully", "id": str(dataset.id)}), 201
+        except Exception as e:
+            logger.error(f"Error creating dataset: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+
+class DatasetDetailAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id, dataset_id):
+        try:
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            serialized = DatasetSerializer().dump(dataset)
+            logger.info(f"Fetched dataset: {dataset_id}")
+            return jsonify({"message": "Dataset fetched successfully", "data": serialized}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error fetching dataset: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+    def put(self, project_id, dataset_id):
+        try:
+            data = request.json
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            dataset.name = data.get("name", dataset.name)
+            dataset.type = data.get("type", dataset.type)
+            dataset.samples = data.get("samples", dataset.samples)
+            dataset.save()
+            logger.info(f"Dataset '{dataset.name}' updated successfully")
+            return jsonify({"message": f"Dataset '{dataset.name}' updated successfully"}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error updating dataset: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+    def delete(self, project_id, dataset_id):
+        try:
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            dataset.delete()
+            logger.info(f"Dataset deleted successfully with id: {dataset_id}")
+            return jsonify({"message": f"Dataset deleted successfully with id: {dataset_id}"}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error deleting dataset: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+
+class DatasetSampleAPI(MethodView):
+    decorators = [login_required]
+
+    def post(self, project_id, dataset_id):
+        try:
+            data = request.json
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            sample = data.get("sample") or {}
+            if sample in dataset.samples:
+                return jsonify({"message": "Sample already exists"}), 400
+            dataset.samples.append(sample)
+            dataset.save()
+            logger.info(f"Sample added to dataset '{dataset_id}'")
+            return jsonify({"message": f"Sample added to dataset '{dataset_id}' successfully"}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error adding sample: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+    def delete(self, project_id, dataset_id, sample_id):
+        try:
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            sample = next((s for s in dataset.samples if s.get("id") == sample_id), None)
+            if not sample:
+                return jsonify({"message": "Sample not found"}), 404
+            dataset.samples.remove(sample)
+            dataset.save()
+            logger.info(f"Sample removed from dataset '{dataset_id}'")
+            return jsonify({"message": f"Sample removed successfully"}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error removing sample: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+    def put(self, project_id, dataset_id, sample_id):
+        try:
+            data = request.json
+            dataset = Dataset.objects.get(id=ObjectId(dataset_id), project__id=ObjectId(project_id))
+            sample = next((s for s in dataset.samples if s.get("id") == sample_id), None)
+            if not sample:
+                return jsonify({"message": "Sample not found"}), 404
+            updated_sample = data.get("updated_sample") or {}
+            index = dataset.samples.index(sample)
+            dataset.samples[index] = updated_sample
+            dataset.save()
+            logger.info(f"Sample updated in dataset '{dataset_id}'")
+            return jsonify({"message": "Sample updated successfully"}), 200
+        except Dataset.DoesNotExist:
+            return jsonify({"message": "Dataset not found"}), 404
+        except Exception as e:
+            logger.error(f"Error updating sample: {str(e)}")
+            return jsonify({"message": str(e)}), 500
+
+
+dataset_bp.add_url_rule("", view_func=DatasetListAPI.as_view("dataset_list_api"), methods=["GET", "POST"])
+dataset_bp.add_url_rule(
+    "/<string:dataset_id>", view_func=DatasetDetailAPI.as_view("dataset_detail_api"), methods=["GET", "PUT", "DELETE"]
+)
+dataset_bp.add_url_rule(
+    "/<string:dataset_id>/samples", view_func=DatasetSampleAPI.as_view("dataset_sample_api"), methods=["POST"]
+)
+dataset_bp.add_url_rule(
+    "/<string:dataset_id>/samples/<string:sample_id>",
+    view_func=DatasetSampleAPI.as_view("dataset_sample_detail_api"),
+    methods=["PUT", "DELETE"],
+)
diff --git a/server/app/api_views/evaluation_view.py b/server/app/api_views/evaluation_view.py
new file mode 100644
index 0000000..0c2936e
--- /dev/null
+++ b/server/app/api_views/evaluation_view.py
@@ -0,0 +1,66 @@
+from bson import ObjectId
+from flask import Blueprint, jsonify, request
+from flask.views import MethodView
+
+from ..config import Logging
+from ..core.services.evaluation_services import (
+    EmbeddingEvaluationStrategy,
+    Evaluator,
+    FuzzyEvaluationStrategy,
+    LLMEvaluationStrategy,
+)
+from ..models import Project
+
+logger = Logging.get_logger(__name__)
+evaluation_bp = Blueprint("evaluation", __name__, url_prefix="/evaluation")
+
+
+class EvaluationAPI(MethodView):
+    def post(self, project_id, agent_id):
+        try:
+            data = request.json
+            input = data.get("input")
+            output = data.get("output")
+            instructions = data.get("instructions")
+            if not all([input, output]):
+                return jsonify({"error": "input and output are required"}), 400
+
+            project = Project.objects.get(id=ObjectId(project_id))
+            agent = next((a for a in project.ai_agents if a.id == ObjectId(agent_id)), None)
+            if not agent:
+                return jsonify({"error": "Agent not found"}), 404
+
+            evaluator_config = agent.agent_config or {}
+            strategy_type = evaluator_config.get("strategy", "llm").lower()
+
+            if strategy_type == "llm":
+                base_guidelines = evaluator_config.get("base_guidelines")
+                if not base_guidelines and instructions:
+                    base_guidelines = instructions
+
+                evaluator_strategy = LLMEvaluationStrategy(config=evaluator_config, guidelines=base_guidelines)
+            elif strategy_type == "embedding":
+                embedding_model = evaluator_config.get("embedding_model", "OpenAI")
+                similarity_metric = evaluator_config.get("similarity_metric", "cosine")
+                if not embedding_model:
+                    return jsonify({"error": "Embedding model not provided in evaluator config"}), 400
+                evaluator_strategy = EmbeddingEvaluationStrategy(
+                    embedding_model=embedding_model, similarity_metric=similarity_metric
+                )
+            elif strategy_type == "fuzzy":
+                evaluator_strategy = FuzzyEvaluationStrategy()
+            else:
+                return jsonify({"error": "Unknown evaluation strategy"}), 400
+
+            evaluator = Evaluator(config=evaluator_config, strategy=evaluator_strategy)
+            score = evaluator.evaluate_pair(input, output)
+
+            return jsonify({"score": score}), 200
+        except Exception as e:
+            logger.error(f"Error during evaluation: {e}")
+            return jsonify({"error": str(e)}), 500
+
+
+evaluation_bp.add_url_rule(
+    "/<string:project_id>/<string:agent_id>", view_func=EvaluationAPI.as_view("evaluation_api"), methods=["POST"]
+)
diff --git a/server/app/api_views/main_view.py b/server/app/api_views/main_view.py
new file mode 100644
index 0000000..ba68e99
--- /dev/null
+++ b/server/app/api_views/main_view.py
@@ -0,0 +1,21 @@
+from flask import Blueprint, redirect, render_template, session
+from flask.views import MethodView
+
+
+class HomeAPI(MethodView):
+    def get(self):
+        if "user" not in session:
+            return redirect("/login")
+        return render_template("index.html")
+
+
+class LoginAPI(MethodView):
+    def get(self):
+        if "user" in session:
+            return redirect("/")
+        return render_template("login.html")
+
+
+main_bp = Blueprint("main", __name__)
+main_bp.add_url_rule("/", view_func=HomeAPI.as_view("home_api"), methods=["GET"])
+main_bp.add_url_rule("/login", view_func=LoginAPI.as_view("login_api"), methods=["GET"])
diff --git a/server/app/api_views/project_view.py b/server/app/api_views/project_view.py
new file mode 100644
index 0000000..bca21dd
--- /dev/null
+++ b/server/app/api_views/project_view.py
@@ -0,0 +1,90 @@
+from bson import ObjectId
+from flask import Blueprint, jsonify, request, session
+from flask.views import MethodView
+
+from ..auth.decorators import login_required
+from ..config import Logging
+from ..models import Project, User
+from ..serializers import ProjectSerializer
+
+logger = Logging.get_logger(__name__)
+project_bp = Blueprint("project", __name__, url_prefix="/projects")
+
+
+class ProjectListAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self):
+        try:
+            firebase_uid = session["user"]["uid"]
+            user = User.objects.get(firebase_uid=firebase_uid)
+            projects = Project.objects.filter(user=user, is_alive=True)
+            serialized = ProjectSerializer(many=True).dump(projects)
+            logger.info(f"Fetched projects for user: {firebase_uid}")
+            return jsonify(
+                {"message": f"Successfully fetched projects for user_id: {str(user.id)}", "data": serialized}
+            )
+        except Exception as e:
+            logger.error(f"Error fetching projects: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def post(self):
+        try:
+            data = request.json
+            firebase_uid = session["user"]["uid"]
+            user = User.objects.get(firebase_uid=firebase_uid)
+            project = Project(
+                user=user,
+                name=data.get("name", "Default Project"),
+                description=data.get("description", ""),
+                ai_agents=[],
+                is_alive=True,
+            ).save()
+            logger.info(f"Project '{project.name}' created successfully")
+            return jsonify({"message": f"Project '{project.name}' created successfully", "id": str(project.id)}), 201
+        except Exception as e:
+            logger.error(f"Error creating project: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+class ProjectDetailAPI(MethodView):
+    decorators = [login_required]
+
+    def get(self, project_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            serialized = ProjectSerializer().dump(project)
+            logger.info(f"Fetched project: {project_id}")
+            return jsonify({"message": f"Successfully fetched project: {project_id}", "data": serialized})
+        except Exception as e:
+            logger.error(f"Error fetching project: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def put(self, project_id):
+        try:
+            data = request.json
+            project = Project.objects.get(id=ObjectId(project_id))
+            project.name = data.get("name", project.name)
+            project.description = data.get("description", project.description)
+            project.save()
+            logger.info(f"Project '{project.name}' updated successfully")
+            return jsonify({"message": f"Project '{project.name}' updated successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error updating project: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+    def delete(self, project_id):
+        try:
+            project = Project.objects.get(id=ObjectId(project_id))
+            project.delete()
+            logger.info("Project deleted successfully")
+            return jsonify({"message": "Project deleted successfully"}), 200
+        except Exception as e:
+            logger.error(f"Error deleting project: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+
+project_bp.add_url_rule("/", view_func=ProjectListAPI.as_view("project_list_api"), methods=["GET", "POST"])
+project_bp.add_url_rule(
+    "/<string:project_id>", view_func=ProjectDetailAPI.as_view("project_detail_api"), methods=["GET", "PUT", "DELETE"]
+)
diff --git a/server/app/auth/__init__.py b/server/app/auth/__init__.py
index e69de29..88e9e3b 100644
--- a/server/app/auth/__init__.py
+++ b/server/app/auth/__init__.py
@@ -0,0 +1,13 @@
+import firebase_admin
+from firebase_admin import auth, credentials
+
+from ..config import Config
+
+# Initialize Firebase once
+creds_path = Config.FIREBASE_CREDS
+if not firebase_admin._apps:
+    cred = credentials.Certificate(creds_path)
+    firebase_admin.initialize_app(cred)
+
+# Create instances
+auth_client = auth
diff --git a/server/app/auth/decorators.py b/server/app/auth/decorators.py
index 00fb2c0..ef4743b 100644
--- a/server/app/auth/decorators.py
+++ b/server/app/auth/decorators.py
@@ -1,10 +1,13 @@
 from functools import wraps
-from flask import session, jsonify
+
+from flask import jsonify, session
+
 
 def login_required(f):
     @wraps(f)
     def decorated_function(*args, **kwargs):
-        if 'user' not in session:
-            return jsonify({'error': 'Authentication required'}), 401
+        if "user" not in session:
+            return jsonify({"error": "Authentication required"}), 401
         return f(*args, **kwargs)
-    return decorated_function
\ No newline at end of file
+
+    return decorated_function
diff --git a/server/app/auth/handlers.py b/server/app/auth/handlers.py
index 67030c1..c9ba01a 100644
--- a/server/app/auth/handlers.py
+++ b/server/app/auth/handlers.py
@@ -1,5 +1,7 @@
 from flask import session
-from ..firebase import auth_client
+
+from . import auth_client
+
 
 class AuthHandler:
     @staticmethod
@@ -15,14 +17,14 @@ def verify_firebase_token(id_token):
     @staticmethod
     def create_session(user_data):
         """Create user session after successful verification"""
-        session['user'] = {
-            'uid': user_data['uid'],
-            'email': user_data.get('email'),
-            'name': user_data.get('name', ''),
-            'picture': user_data.get('picture', '')
+        session["user"] = {
+            "uid": user_data["uid"],
+            "email": user_data.get("email"),
+            "name": user_data.get("name", ""),
+            "picture": user_data.get("picture", ""),
         }
 
     @staticmethod
     def clear_session():
         """Clear user session"""
-        session.pop('user', None)
\ No newline at end of file
+        session.pop("user", None)
diff --git a/server/app/config.py b/server/app/config.py
index 12201df..ae14a0b 100644
--- a/server/app/config.py
+++ b/server/app/config.py
@@ -1,38 +1,87 @@
+import logging
 import os
 from pathlib import Path
+from typing import Optional
+
 from dotenv import load_dotenv
 
 load_dotenv()
 
+
 class Config:
     # Root directory (project root)
     ROOT_DIR = Path(__file__).parents[2]
 
     # Firebase config
-    FIREBASE_CREDS = ROOT_DIR / 'firebase-credentials.json'
+    FIREBASE_CREDS = ROOT_DIR / "firebase-credentials.json"
+
+    # Mongo config
+    MONGO_URI = os.environ.get("MONGO_URI")
 
     # Flask config
-    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-key'
+    SECRET_KEY = os.environ.get("SECRET_KEY") or "dev-key"
 
     # API Keys
-    CLAUDE_API_KEY = os.environ.get('CLAUDE_API_KEY')
-    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
-    
+    CLAUDE_API_KEY = os.environ.get("CLAUDE_API_KEY")
+    OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+
     # File paths
-    FILE_DIR = ROOT_DIR / 'server' / 'data'  # server/data directory
-    CHARACTERS_FILE = os.path.join(FILE_DIR, 'characters.json')
-    DATASETS_FILE = os.path.join(FILE_DIR, 'datasets.json')
-    
+    FILE_DIR = ROOT_DIR / "server" / "data"  # server/data directory
+    CHARACTERS_FILE = os.path.join(FILE_DIR, "characters.json")
+    DATASETS_FILE = os.path.join(FILE_DIR, "datasets.json")
+
     # Model defaults
     DEFAULT_CLAUDE_MODEL = "claude-3-5-sonnet-20240620"
     DEFAULT_OPENAI_MODEL = "gpt-4"
+    DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small"
+    DEFAULT_CLAUDE_EMBEDDING_MODEL = "claude-3-5-sonnet-20241022"
     DEFAULT_MAX_TOKENS = 4096
     DEFAULT_TEMPERATURE = 0.7
 
-    CORS_HEADERS = 'Content-Type'
-    
+    CORS_HEADERS = "Content-Type"
+
     # If you're serving frontend from a different port in development
-    CORS_ORIGINS = [
-        "http://localhost:5000",
-        "http://127.0.0.1:5000"
-    ]
\ No newline at end of file
+    CORS_ORIGINS = ["http://localhost:5000", "http://127.0.0.1:5000"]
+
+
+class Logging:
+    _is_configured = False
+
+    @classmethod
+    def initialize(cls, log_level: int = logging.INFO, log_file: str = "app.log") -> None:
+        """
+        Initializes the logging configuration. This method ensures logging is configured only once.
+
+        Args:
+            log_level (int): Logging level (e.g., logging.INFO, logging.DEBUG).
+            log_file (str): Path to the log file.
+        """
+        if cls._is_configured:
+            return
+
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            handlers=[
+                logging.FileHandler(log_file),  # Log to a file
+                logging.StreamHandler(),  # Log to the console
+            ],
+        )
+        cls._is_configured = True
+
+    @staticmethod
+    def get_logger(name: str, level: Optional[int] = None) -> logging.Logger:
+        """
+        Retrieves a logger with the given name. Optionally adjusts the logging level for this logger.
+
+        Args:
+            name (str): Name of the logger, typically `__name__`.
+            level (Optional[int]): Logging level for this logger (overrides global log level).
+
+        Returns:
+            Logger: Configured logger instance.
+        """
+        logger = logging.getLogger(name)
+        if level is not None:
+            logger.setLevel(level)
+        return logger
diff --git a/server/app/core/characters.py b/server/app/core/characters.py
deleted file mode 100644
index 3ec2320..0000000
--- a/server/app/core/characters.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import Dict, Optional
-from ..firebase import character_dao
-
-def get_all_characters(user_id: str) -> Dict:
-    """Get all characters for a user"""
-    return character_dao.get_all(user_id)
-
-def save_character(name: str, backstory: str, model: str, temperature: float, max_tokens: int, user_id: str) -> str:
-    """Create new character"""
-    return character_dao.save(name, backstory, model, temperature, max_tokens, user_id)
-
-def delete_character(character_id: str, user_id: str) -> bool:
-    """Delete a character"""
-    return character_dao.delete(character_id, user_id)
-
-def get_character(character_id: str, user_id: str) -> Optional[Dict]:
-    """Get a specific character"""
-    return character_dao.get_by_id(character_id, user_id)
-
-def update_character(character_id: str, name: str, backstory: str, model: str, temperature: float, max_tokens: int, user_id: str) -> bool:
-    """Update existing character"""
-    return character_dao.update(character_id, name, backstory, model, temperature, max_tokens, user_id)
\ No newline at end of file
diff --git a/server/app/core/datasets.py b/server/app/core/datasets.py
deleted file mode 100644
index 1a14447..0000000
--- a/server/app/core/datasets.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import Dict, List
-from ..firebase import dataset_dao
-
-def get_all_datasets(user_id: str) -> Dict:
-    """Get all datasets for a user"""
-    return dataset_dao.get_all(user_id)
-
-def save_dataset(name: str, metric_name: str, metric_description: str, questions: List[str], user_id: str) -> str:
-    """Create new dataset"""
-    return dataset_dao.save(name, metric_name, metric_description, questions, user_id)
-
-def delete_dataset(dataset_id: str, user_id: str) -> bool:
-    """Delete a dataset"""
-    return dataset_dao.delete(dataset_id, user_id)
-
-def get_dataset(dataset_id: str, user_id: str) -> Dict:
-    """Get a specific dataset"""
-    return dataset_dao.get_by_id(dataset_id, user_id)
-
-def update_dataset(dataset_id: str, name: str, metric_name: str, metric_description: str, questions: List[str], user_id: str) -> bool:
-    """Update existing dataset"""
-    return dataset_dao.update(dataset_id, name, metric_name, metric_description, questions, user_id)
\ No newline at end of file
diff --git a/server/app/core/models.py b/server/app/core/models.py
deleted file mode 100644
index e68b5c1..0000000
--- a/server/app/core/models.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from ..utils import (
-    get_response_claude, 
-    get_response_openai, 
-    system_metric, 
-    system_score
-)
-
-class Character:
-    def __init__(self, name:str, backstory:str, user: str):
-        self.name = name 
-        self.backstory = backstory 
-        self.user = user
-
-        self.build_prompt()
-
-    def build_prompt(self):
-
-        system = f"""You are acting as {self.name} and you are talking to {self.user}, and your backstory is as follows:
-        
-        {self.backstory}.
-        
-        You have to enact this character properly, and behave as the same, never reveal you are an AI"""
-
-        self.prompt_system = system
-        
-class Evaluator:
-
-    def __init__(self, metric: dict, character: Character, n: int, model_type: str = "claude"):
-
-        self.metric = metric
-        self.character = character 
-        self.num_q = n 
-        self.response_function = eval(f"get_response_{model_type}")
-    
-    def generate_questions(self):
-
-        system_prompt = system_metric.format(num_q = self.num_q, metric_name = self.metric["name"], metric_desc = self.metric["description"],backstory = self.character.backstory)
-        prompt = [
-            {
-                "role":"system",
-                "content": ""
-            },
-            {
-                "role":"user",
-                "content":system_prompt
-            }
-        ]
-    
-            # kinda retry mechanism, agar response is not exactly a list object in python, then we will regenerate the response
-        try:
-            raw_questions = get_response_claude(prompt=prompt)
-            questions = eval(raw_questions)
-            self.questions = questions
-        except:
-            self.generate_questions()        
-        
-        print("These are the generated questions: ", "\n")
-        for question in self.questions:
-            print(question, "\n")
-    
-    def score_response(self,response:str) -> int:
-
-        system_prompt = system_score.format(metric_name = self.metric["name"], metric_desc = self.metric["description"])
-        
-        prompt = [
-            {
-                "role":"system",
-                "content":system_prompt
-            },
-            {
-                "role":"user",
-                "content":"The AI response which needs to be scored is: " + response
-            }
-        ]
-
-        try:
-            score = self.response_function(prompt)
-        except:
-            score = self.score_response(response)
-        
-        return score 
-    
-    def test_model(self, questions=None):
-        if questions is None:
-            self.generate_questions()
-            questions = self.questions
-        
-        results = []
-
-        for question in questions:
-            prompt = [
-                {
-                    "role": "system",
-                    "content": self.character.prompt_system
-                },
-                {
-                    "role": "user",
-                    "content": question
-                }
-            ]
-
-            response = self.response_function(prompt)
-            score = int(self.score_response(response).strip())
-            
-            results.append((question, response, score))
-
-        return results
diff --git a/server/app/core/services/embedding_service.py b/server/app/core/services/embedding_service.py
new file mode 100644
index 0000000..c2c076e
--- /dev/null
+++ b/server/app/core/services/embedding_service.py
@@ -0,0 +1,86 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from ...config import Config, Logging
+from ...utils.api_clients import ClaudeClient, OpenAIClient
+
+logger = Logging.get_logger(__name__)
+
+
+class EmbeddingModel(ABC):
+    """
+    Abstract base class for embedding models.
+    """
+
+    @abstractmethod
+    def encode(self, text: str) -> np.ndarray:
+        pass
+
+
+class OpenAIEmbeddingModel(EmbeddingModel):
+    def __init__(self, model_name: str = Config.DEFAULT_OPENAI_EMBEDDING_MODEL):
+        self.model_name = model_name
+        self.client = OpenAIClient()
+
+    def encode(self, text: str) -> np.ndarray:
+        return self.client.get_embeddings(text, self.model_name)
+
+
+class ClaudeEmbeddingModel(EmbeddingModel):
+    def __init__(self, model_name: str = Config.DEFAULT_CLAUDE_EMBEDDING_MODEL):
+        self.model_name = model_name
+        self.client = ClaudeClient()
+
+    def encode(self, text: str) -> np.ndarray:
+        return self.client.get_embeddings(text, self.model_name)
+
+
+class SimilarityMetric(ABC):
+    """
+    Abstract base class for similarity metrics.
+    """
+
+    @abstractmethod
+    def compute(self, vector_a: np.ndarray, vector_b: np.ndarray) -> float:
+        pass
+
+
+class CosineSimilarity(SimilarityMetric):
+    def compute(self, vector_a: np.ndarray, vector_b: np.ndarray) -> float:
+        return np.dot(vector_a, vector_b) / (np.linalg.norm(vector_a) * np.linalg.norm(vector_b) + 1e-8)
+
+
+class EuclideanSimilarity(SimilarityMetric):
+    def compute(self, vector_a: np.ndarray, vector_b: np.ndarray) -> float:
+        return np.linalg.norm(vector_a - vector_b)
+
+
+class EmbeddingService:
+    """
+    Service to handle embedding operations.
+    """
+
+    def __init__(self, model: EmbeddingModel, similarity_metric: SimilarityMetric):
+        self.model = model
+        self.similarity_metric = similarity_metric
+
+    def get_embedding(self, text: str) -> np.ndarray:
+        try:
+            embedding = self.model.encode(text)
+            logger.info(f"Generated embedding for text: {text[:30]}...")
+            return embedding
+        except Exception as e:
+            logger.error(f"Failed to generate embedding: {e}")
+            raise
+
+    def get_embedding_similarity(self, text_a: str, text_b: str) -> float:
+        try:
+            emb_a = self.model.encode(text_a)
+            emb_b = self.model.encode(text_b)
+            similarity = self.similarity_metric.compute(emb_a, emb_b)
+            logger.info(f"Computed similarity: {similarity}")
+            return similarity
+        except Exception as e:
+            logger.error(f"Failed to compare embeddings: {e}")
+            raise
diff --git a/server/app/core/services/evaluation_services.py b/server/app/core/services/evaluation_services.py
new file mode 100644
index 0000000..04228ee
--- /dev/null
+++ b/server/app/core/services/evaluation_services.py
@@ -0,0 +1,185 @@
+from abc import ABC, abstractmethod
+
+from fuzzywuzzy import fuzz
+
+from ...config import Config, Logging
+from ..services.embedding_service import (
+    ClaudeEmbeddingModel,
+    CosineSimilarity,
+    EmbeddingService,
+    EuclideanSimilarity,
+    OpenAIEmbeddingModel,
+)
+from ..services.llm_service import LLMResponseService
+
+logger = Logging.get_logger(__name__)
+
+# Embedding models
+embedding_model_map = {"OpenAI": OpenAIEmbeddingModel, "Anthropic": ClaudeEmbeddingModel}
+
+# Similarity metrics
+similarity_metric_map = {"cosine": CosineSimilarity, "euclidean": EuclideanSimilarity}
+
+
+class EvaluationStrategy(ABC):
+    """
+    Abstract class for evaluation strategies
+    """
+
+    @abstractmethod
+    def evaluate(self, input_text: str, output_text: str, **kwargs):
+        pass
+
+
+class LLMEvaluationStrategy(EvaluationStrategy):
+    """
+    Strategy using an LLM for evaluation
+    """
+
+    def __init__(self, config: dict, guidelines: str):
+        self.config = config
+        self.model = config.get("model", "gpt-4o")
+        self.max_tokens = config.get("max_tokens", Config.DEFAULT_MAX_TOKENS)
+        self.temperature = config.get("temperature", Config.DEFAULT_TEMPERATURE)
+        self.guidelines = guidelines
+
+    def _get_prompt(self, input_text: str, output_text: str):
+        if self.guidelines:
+            prompt = [
+                {
+                    "role": "system",
+                    "content": "You are an evaluator. Your task is to evaluate the output based on the given input and instructions.",
+                },
+                {"role": "user", "content": f"Instructions: {self.guidelines}"},
+                {"role": "user", "content": f"Input: {input_text}"},
+                {"role": "user", "content": f"Output: {output_text}"},
+                {"role": "user", "content": "Score the output between either 0 or 1."},
+            ]
+        else:
+            prompt = [
+                {
+                    "role": "system",
+                    "content": "You are an evaluator. Your task is to evaluate the output based on the given input.",
+                },
+                {"role": "user", "content": f"Input: {input_text}"},
+                {"role": "user", "content": f"Output: {output_text}"},
+                {"role": "user", "content": "Score the output between either 0 or 1."},
+            ]
+        return prompt
+
+    def _validate_response_conformity_with_instructions(self, response: str):
+        if self.guidelines:
+            prompt = [
+                {
+                    "role": "system",
+                    "content": "You are an evaluator. Your task is to evaluate the output based on the given input and instructions.",
+                },
+                {"role": "user", "content": f"Instructions: {self.guidelines}"},
+                {"role": "user", "content": f"Evaluator's response: {response}"},
+                {
+                    "role": "user",
+                    "content": "Check if the response is consistent with the instructions. If it is, return 'True'. If it is not, return 'False'.",
+                },
+            ]
+
+            # initialize LLMResponseService
+            llm_response_service = LLMResponseService(
+                model=self.model,
+                prompt=prompt,
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+            )
+
+            # get response
+            response = llm_response_service.get_response()
+
+            # validate response
+            if response == "True":
+                logger.info(f"Response is consistent with the instructions. Response: {response}")
+                return True
+            else:
+                logger.error(f"Response is not consistent with the instructions. Response: {response}")
+                return False
+        else:
+            # If there are no instructions, check if score is between 0 and 100
+            if 0 <= int(response) <= 1:
+                logger.info(f"Response is between 0 and 1. Response: {response}")
+                return True
+            else:
+                logger.error(f"Response is not between 0 and 1. Response: {response}")
+                return False
+
+    def evaluate(self, input_text: str, output_text: str, max_retries: int = 3):
+        prompt = self._get_prompt(input_text, output_text)
+
+        # unpack config and initialize LLMResponseService
+        llm_response_service = LLMResponseService(
+            model=self.model,
+            prompt=prompt,
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+        )
+
+        # get response
+        response = llm_response_service.get_response()
+
+        # validate response
+        validation_passed = self._validate_response_conformity_with_instructions(response)
+
+        # If validation failed, re-try again
+        if not validation_passed:
+            # re-try again
+            if max_retries > 0:
+                return self.evaluate(input_text, output_text, max_retries - 1)
+            else:
+                logger.error(f"Response is not consistent with the instructions. Response: {response}")
+                return False
+
+        if not validation_passed:
+            raise ValueError(f"Response is not consistent with the instructions. Response: {response}")
+        return response
+
+
+class EmbeddingEvaluationStrategy(EvaluationStrategy):
+    """
+    Strategy using embedding similarity for evaluation.
+    Supports multiple similarity metrics.
+    """
+
+    def __init__(self, embedding_model: str, similarity_metric: str = "cosine"):
+        self.embedding_model = embedding_model_map.get(embedding_model)()
+        self.similarity_metric = similarity_metric_map.get(similarity_metric)()
+        self.embedding_service = EmbeddingService(self.embedding_model, self.similarity_metric)
+
+    def evaluate(self, input_text: str, output_text: str, **kwargs):
+        try:
+            similarity = self.embedding_service.get_embedding_similarity(input_text, output_text)
+            return similarity
+        except Exception as e:
+            logger.error(f"Error in embedding evaluation: {e}")
+            return None
+
+
+class FuzzyEvaluationStrategy(EvaluationStrategy):
+    """
+    Strategy using fuzzy matching for evaluation
+    """
+
+    def evaluate(self, input_text: str, output_text: str, **kwargs):
+        score = fuzz.ratio(input_text, output_text)
+        return score
+
+
+class Evaluator:
+    """
+    Evaluator class takes config and a strategy instance
+    """
+
+    def __init__(self, config: dict, strategy: EvaluationStrategy):
+        self.config = config
+        self.strategy = strategy
+
+    def evaluate_pair(self, input: str, output: str):
+        score = self.strategy.evaluate(input, output)
+        logger.info(f"Evaluator scored {score} for input: {input} and output: {output}")
+        return score
diff --git a/server/app/core/services/llm_service.py b/server/app/core/services/llm_service.py
new file mode 100644
index 0000000..6dfd320
--- /dev/null
+++ b/server/app/core/services/llm_service.py
@@ -0,0 +1,46 @@
+from ...config import Config
+from ...utils.api_clients import ClaudeClient, OpenAIClient
+from ...utils.model_map import get_model_type
+
+llm_clients = {"OpenAI": OpenAIClient, "Anthropic": ClaudeClient}
+
+
+class LLMResponseService:
+    def __init__(
+        self,
+        model: str,
+        prompt: list[dict],
+        max_tokens: int = Config.DEFAULT_MAX_TOKENS,
+        temperature: float = Config.DEFAULT_TEMPERATURE,
+        stream: bool = False,
+    ) -> None:
+        self.model_type = get_model_type(model)
+        self.llm_client = llm_clients.get(self.model_type)
+        self.model = model
+        self.prompt = prompt
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self.stream = stream
+        self._validate_prompt()
+
+    def _validate_prompt(self):
+        if not self.prompt:
+            raise ValueError("Prompt is required")
+        if not isinstance(self.prompt, list):
+            raise ValueError("Prompt should be a list of dictionaries")
+        for p in self.prompt:
+            if not isinstance(p, dict):
+                raise ValueError("Prompt should be a list of dictionaries")
+            if "role" not in p:
+                raise ValueError("Prompt should have a role key")
+            if "content" not in p:
+                raise ValueError("Prompt should have a content key")
+
+    def get_response(self):
+        return self.llm_client().get_response(
+            prompt=self.prompt,
+            model=self.model,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stream=self.stream,
+        )
diff --git a/server/app/enums.py b/server/app/enums.py
new file mode 100644
index 0000000..3c32199
--- /dev/null
+++ b/server/app/enums.py
@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class DataSetTypes(Enum):
+    KEY_VALUE = "KEY_VALUE"
+    MULTI_TURN = "MULTI_TURN"
diff --git a/server/app/firebase/__init__.py b/server/app/firebase/__init__.py
deleted file mode 100644
index 383effb..0000000
--- a/server/app/firebase/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import firebase_admin
-from firebase_admin import credentials, firestore, auth
-from ..config import Config
-
-# Initialize Firebase once
-creds_path = Config.FIREBASE_CREDS
-if not firebase_admin._apps:
-    cred = credentials.Certificate(creds_path)
-    firebase_admin.initialize_app(cred)
-
-# Create instances
-db = firestore.client()
-auth_client = auth
-
-# Export both services
-__all__ = ['db', 'auth_client']
\ No newline at end of file
diff --git a/server/app/firebase/character_dao.py b/server/app/firebase/character_dao.py
deleted file mode 100644
index 60016c3..0000000
--- a/server/app/firebase/character_dao.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from typing import Dict, Optional
-from . import db
-
-def get_all(user_id: str) -> Dict:
-    """Get all characters for a specific user"""
-    characters = {}
-    query = db.collection('characters').where('user_id', '==', user_id).stream()
-    for doc in query:
-        characters[doc.id] = doc.to_dict()
-    return characters
-
-def get_by_id(char_id: str, user_id: str) -> Optional[Dict]:
-    """Get a specific character if it belongs to the user"""
-    doc_ref = db.collection('characters').document(char_id)
-    doc = doc_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        return doc.to_dict()
-    return None
-
-def save(name: str, backstory: str, model: str, temperature: float, max_tokens: int, user_id: str) -> str:
-    """Save new character with user_id"""
-    doc_ref = db.collection('characters').document()
-    
-    character_data = {
-        "name": name,
-        "backstory": backstory,
-        "model": model,
-        "temperature": float(temperature),
-        "max_tokens": int(max_tokens),
-        "user_id": user_id
-    }
-    
-    doc_ref.set(character_data)
-    return doc_ref.id
-
-def update(char_id: str, name: str, backstory: str, model: str, temperature: float, max_tokens: int, user_id: str) -> bool:
-    """Update existing character if it belongs to the user"""
-    char_ref = db.collection('characters').document(char_id)
-    doc = char_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        char_ref.update({
-            "name": name,
-            "backstory": backstory,
-            "model": model,
-            "temperature": float(temperature),
-            "max_tokens": int(max_tokens)
-        })
-        return True
-    return False
-
-def delete(char_id: str, user_id: str) -> bool:
-    """Delete a character if it belongs to the user"""
-    char_ref = db.collection('characters').document(char_id)
-    doc = char_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        char_ref.delete()
-        return True
-    return False
\ No newline at end of file
diff --git a/server/app/firebase/dataset_dao.py b/server/app/firebase/dataset_dao.py
deleted file mode 100644
index 67c1701..0000000
--- a/server/app/firebase/dataset_dao.py
+++ /dev/null
@@ -1,59 +0,0 @@
-from typing import Dict, Optional, List
-from . import db
-
-def get_all(user_id: str) -> Dict:
-    """Get all datasets for a specific user"""
-    datasets = {}
-    query = db.collection('datasets').where('user_id', '==', user_id).stream()
-    for doc in query:
-        datasets[doc.id] = doc.to_dict()
-    return datasets
-
-def get_by_id(dataset_id: str, user_id: str) -> Optional[Dict]:
-    """Get a specific dataset if it belongs to the user"""
-    doc_ref = db.collection('datasets').document(dataset_id)
-    doc = doc_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        return doc.to_dict()
-    return None
-
-def save(name: str, metric_name: str, metric_description: str, questions: List[str], user_id: str) -> str:
-    """Save new dataset with user_id"""
-    doc_ref = db.collection('datasets').document()
-    
-    dataset_data = {
-        "name": name,
-        "metric_name": metric_name,
-        "metric_description": metric_description,
-        "questions": questions,
-        "user_id": user_id
-    }
-    
-    doc_ref.set(dataset_data)
-    return doc_ref.id
-
-def update(dataset_id: str, name: str, metric_name: str, metric_description: str, questions: List[str], user_id: str) -> bool:
-    """Update existing dataset if it belongs to the user"""
-    dataset_ref = db.collection('datasets').document(dataset_id)
-    doc = dataset_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        dataset_ref.update({
-            "name": name,
-            "metric_name": metric_name,
-            "metric_description": metric_description,
-            "questions": questions
-        })
-        return True
-    return False
-
-def delete(dataset_id: str, user_id: str) -> bool:
-    """Delete a dataset if it belongs to the user"""
-    dataset_ref = db.collection('datasets').document(dataset_id)
-    doc = dataset_ref.get()
-    
-    if doc.exists and doc.to_dict().get('user_id') == user_id:
-        dataset_ref.delete()
-        return True
-    return False
\ No newline at end of file
diff --git a/server/app/firebase/evaluations_dao.py b/server/app/firebase/evaluations_dao.py
deleted file mode 100644
index 591452f..0000000
--- a/server/app/firebase/evaluations_dao.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from firebase_admin import firestore
-from typing import Dict, Optional, List
-from datetime import datetime
-
-def create(evaluation_data: Dict) -> str:
-    """Create a new evaluation"""
-    db = firestore.client()
-    eval_ref = db.collection('evaluations').document()
-    
-    # Add timestamp
-    evaluation_data['created_at'] = datetime.now(datetime.UTC)
-    
-    eval_ref.set(evaluation_data)
-    return eval_ref.id
-
-def get_by_id(eval_id: str) -> Optional[Dict]:
-    """Get a specific evaluation by ID"""
-    db = firestore.client()
-    doc_ref = db.collection('evaluations').document(eval_id)
-    doc = doc_ref.get()
-    
-    if doc.exists:
-        return doc.to_dict()
-    return None
-
-def get_by_character(char_id: str) -> List[Dict]:
-    """Get all evaluations for a specific character"""
-    db = firestore.client()
-    evals_ref = db.collection('evaluations')
-    evals = evals_ref.where('character_id', '==', char_id).stream()
-    
-    return [eval_doc.to_dict() for eval_doc in evals]
-
-def get_by_dataset(dataset_id: str) -> List[Dict]:
-    """Get all evaluations for a specific dataset"""
-    db = firestore.client()
-    evals_ref = db.collection('evaluations')
-    evals = evals_ref.where('dataset_id', '==', dataset_id).stream()
-    
-    return [eval_doc.to_dict() for eval_doc in evals]
\ No newline at end of file
diff --git a/server/app/models.py b/server/app/models.py
new file mode 100644
index 0000000..eb0076e
--- /dev/null
+++ b/server/app/models.py
@@ -0,0 +1,91 @@
+# models.py
+from bson import ObjectId
+from mongoengine import (
+    DENY,
+    BooleanField,
+    DateTimeField,
+    DictField,
+    Document,
+    EmailField,
+    EmbeddedDocument,
+    EmbeddedDocumentField,
+    ListField,
+    ObjectIdField,
+    ReferenceField,
+    StringField,
+)
+
+from server.app.utils.datetime_utils import get_datetime_in_ist
+
+from .enums import DataSetTypes
+
+
+class BaseDocument(Document):
+    is_alive = BooleanField(default=True)
+    added_on = DateTimeField(default=get_datetime_in_ist())
+    updated_on = DateTimeField(default=get_datetime_in_ist())
+
+    meta = {"abstract": True}
+
+    def save(self, *args, **kwargs):
+        if not self.added_on:
+            self.added_on = get_datetime_in_ist()
+        self.updated_on = get_datetime_in_ist()
+        return super(BaseDocument, self).save(*args, **kwargs)
+
+
+class BaseEmbeddedDocument(EmbeddedDocument):
+    id = ObjectIdField(default=lambda: ObjectId())
+    is_alive = BooleanField(default=True)
+    added_on = DateTimeField(default=get_datetime_in_ist())
+    updated_on = DateTimeField(default=get_datetime_in_ist())
+
+    meta = {"allow_inheritance": True}
+
+    def save(self, *args, **kwargs):
+        if not self.added_on:
+            self.added_on = get_datetime_in_ist()
+        self.updated_on = get_datetime_in_ist()
+        return super(BaseEmbeddedDocument, self).save(*args, **kwargs)
+
+
+class User(BaseDocument):
+    name = StringField(required=True, min_length=1)
+    firebase_uid = StringField(required=True, unique=True)
+    picture = StringField()
+    email = EmailField(required=True, unique=True)
+
+    meta = {"collection": "users"}
+
+
+class AIAgentVariant(BaseEmbeddedDocument):
+    name = StringField(required=True)
+    variables = DictField(required=True)
+
+
+class AIAgent(BaseEmbeddedDocument):
+    name = StringField(required=True)
+    agent_config = DictField(required=True)
+    prompt = ListField(DictField(required=True))
+    included_variables = ListField(StringField())
+    variants = ListField(EmbeddedDocumentField(AIAgentVariant))
+
+    meta = {"collection": "ai_agents"}
+
+
+class Project(BaseDocument):
+    name = StringField(required=True, min_length=1)
+    user = ReferenceField(User, required=True, reverse_delete_rule=DENY)
+    description = StringField()
+    ai_agents = ListField(EmbeddedDocumentField(AIAgent))
+
+    meta = {"collection": "projects"}
+
+
+class Dataset(BaseDocument):
+    project = ReferenceField(Project, required=True, reverse_delete_rule=DENY)
+    name = StringField(required=True, min_length=1)
+    type = StringField(required=True, choices=[item.value for item in DataSetTypes])
+    samples = ListField(DictField(), required=True)
+
+    meta = {"collection": "datasets"}
diff --git a/server/app/serializers.py b/server/app/serializers.py
new file mode 100644
index 0000000..568c789
--- /dev/null
+++ b/server/app/serializers.py
@@ -0,0 +1,32 @@
+from marshmallow_mongoengine import ModelSchema, fields
+
+from .models import *
+
+
+class UserSerializer(ModelSchema):
+    class Meta:
+        model = User
+
+
+class AIAgentVariantSerializer(ModelSchema):
+    class Meta:
+        model = AIAgentVariant
+
+
+class AIAgentSerializer(ModelSchema):
+    variants = fields.Nested(AIAgentVariantSerializer, many=True)
+
+    class Meta:
+        model = AIAgent
+
+
+class ProjectSerializer(ModelSchema):
+    ai_agents = fields.Nested(AIAgentSerializer, many=True)
+
+    class Meta:
+        model = Project
+
+
+class DatasetSerializer(ModelSchema):
+    class Meta:
+        model = Dataset
diff --git a/server/app/utils/__init__.py b/server/app/utils/__init__.py
index 9fb35b5..e69de29 100644
--- a/server/app/utils/__init__.py
+++ b/server/app/utils/__init__.py
@@ -1,9 +0,0 @@
-from .api_clients import get_response_claude, get_response_openai
-from .prompts import system_metric, system_score
-
-__all__ = [
-    'get_response_claude',
-    'get_response_openai',
-    'system_metric',
-    'system_score'
-]
\ No newline at end of file
diff --git a/server/app/utils/api_clients.py b/server/app/utils/api_clients.py
index 1a2aa24..5ac1a73 100644
--- a/server/app/utils/api_clients.py
+++ b/server/app/utils/api_clients.py
@@ -1,37 +1,91 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
 from anthropic import Anthropic
 from openai import OpenAI
+
 from ..config import Config
 
-def get_response_claude(
-    prompt: list,
-    model: str = Config.DEFAULT_CLAUDE_MODEL,
-    temp: float = Config.DEFAULT_TEMPERATURE,
-    max_tokens: int = Config.DEFAULT_MAX_TOKENS
-) -> str:
-    client = Anthropic(api_key=Config.CLAUDE_API_KEY)
-
-    message = client.messages.create(
-        model=model,
-        max_tokens=max_tokens,
-        temperature=temp,
-        system=prompt[0]["content"],
-        messages=prompt[1:]
-    )
-    return message.content[0].text
-
-def get_response_openai(
-    prompt: list,
-    model: str = Config.DEFAULT_OPENAI_MODEL,
-    max_tokens: int = Config.DEFAULT_MAX_TOKENS,
-    temp: float = Config.DEFAULT_TEMPERATURE
-) -> str:
-    client = OpenAI(api_key=Config.OPENAI_API_KEY)
-
-    completion = client.chat.completions.create(
-        model=model,
-        messages=prompt,
-        temperature=temp,
-        max_tokens=max_tokens
-    )
-
-    return completion.choices[0].message.content
\ No newline at end of file
+
+class BaseClient(ABC):
+    @abstractmethod
+    def get_response(self, prompt: list, model: str, temperature: float, max_tokens: int, stream: bool):
+        pass
+
+    @abstractmethod
+    def get_embeddings(self, input: str, model: str):
+        pass
+
+
+class ClaudeClient(BaseClient):
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key
+        if not self.api_key:
+            self.api_key = Config.CLAUDE_API_KEY
+        self.client = Anthropic(api_key=self.api_key)
+
+    def _get_response_stream(self, message):
+        """Helper function to handle streaming responses"""
+        for response in message:
+            if response.type == "content_block_delta":
+                yield response.delta.text
+
+    def get_response(
+        self,
+        prompt: list,
+        model: str = Config.DEFAULT_CLAUDE_MODEL,
+        temperature: float = Config.DEFAULT_TEMPERATURE,
+        max_tokens: int = Config.DEFAULT_MAX_TOKENS,
+        stream: bool = False,
+    ):
+        message = self.client.messages.create(
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            system=prompt[0]["content"],
+            messages=prompt[1:],
+            stream=stream,
+        )
+
+        if stream:
+            return self._get_response_stream(message)
+
+        return message.content[0].text
+
+    def get_embeddings(self, input: str, model: str = Config.DEFAULT_CLAUDE_EMBEDDING_MODEL):
+        response = self.client.embeddings.create(input=input, model=model)
+        return np.array(response.data[0].embedding)
+
+
+class OpenAIClient(BaseClient):
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key
+        if not self.api_key:
+            self.api_key = Config.OPENAI_API_KEY
+        self.client = OpenAI(api_key=self.api_key)
+
+    def _get_response_stream(self, completion):
+        """Helper function to handle OpenAI streaming responses"""
+        for response in completion:
+            yield response.choices[0].delta.content or ""
+
+    def get_response(
+        self,
+        prompt: list,
+        model: str = Config.DEFAULT_OPENAI_MODEL,
+        max_tokens: int = Config.DEFAULT_MAX_TOKENS,
+        temperature: float = Config.DEFAULT_TEMPERATURE,
+        stream: bool = False,
+    ):
+        completion = self.client.chat.completions.create(
+            model=model, messages=prompt, temperature=temperature, max_tokens=max_tokens, stream=stream
+        )
+
+        if stream:
+            return self._get_response_stream(completion)
+
+        return completion.choices[0].message.content
+
+    def get_embeddings(self, input: str, model: str = Config.DEFAULT_OPENAI_EMBEDDING_MODEL):
+        response = self.client.embeddings.create(input=input, model=model)
+        return np.array(response.data[0].embedding)
diff --git a/server/app/utils/datetime_utils.py b/server/app/utils/datetime_utils.py
new file mode 100644
index 0000000..9b1f2f8
--- /dev/null
+++ b/server/app/utils/datetime_utils.py
@@ -0,0 +1,8 @@
+from datetime import datetime, timedelta, timezone
+
+
+def get_datetime_in_ist(datetime_obj=None):
+    """Converts a UTC datetime object to IST timezone"""
+    if not datetime_obj:
+        datetime_obj = datetime.now()
+    return datetime_obj.astimezone(timezone(timedelta(hours=5, minutes=30)))
diff --git a/server/app/utils/exceptions.py b/server/app/utils/exceptions.py
deleted file mode 100644
index 1d143b3..0000000
--- a/server/app/utils/exceptions.py
+++ /dev/null
@@ -1,11 +0,0 @@
-class APIError(Exception):
-    """Base exception for API errors"""
-    pass
-
-class ModelError(APIError):
-    """Raised when there's an error with the AI model response"""
-    pass
-
-class ValidationError(APIError):
-    """Raised when there's an error with input validation"""
-    pass
\ No newline at end of file
diff --git a/server/app/utils/model_map.py b/server/app/utils/model_map.py
new file mode 100644
index 0000000..ec8cf68
--- /dev/null
+++ b/server/app/utils/model_map.py
@@ -0,0 +1,20 @@
+LLM_MODELS = {
+    "OpenAI": [
+        {"id": "gpt-4o", "name": "GPT-4"},
+        {"id": "gpt-4-turbo", "name": "GPT-4 Turbo"},
+        {"id": "gpt-3.5-turbo", "name": "GPT-3.5 Turbo"},
+        {"id": "gpt-4o-mini", "name": "GPT-4 Mini"},
+        {"id": "gpt-4-1106-preview", "name": "GPT-4 Preview"},
+    ],
+    "Anthropic": [
+        {"id": "claude-3-5-sonnet-20241022", "name": "Claude 3 Sonnet"},
+        {"id": "claude-3-5-haiku-20241022", "name": "Claude 3 Haiku"},
+    ],
+}
+
+
+def get_model_type(model):
+    for provider, models in LLM_MODELS.items():
+        if any(m["id"] == model for m in models):
+            return provider
+    return None
diff --git a/server/app/utils/prompts.py b/server/app/utils/prompts.py
index 3e33376..471dd07 100644
--- a/server/app/utils/prompts.py
+++ b/server/app/utils/prompts.py
@@ -1,24 +1,90 @@
-system_metric = """You have to generate a set of questions to evaluate an AI character. Make sure that you generate a diverse set of {num_q} questions only.
+system_score = """
+You are acting as an LLM as a judge thing. Below is the evaluation description that you are going to undertake:
+
+<eval_description>
+{eval_desc}
+</eval_description>
 
-        You are generating questions to evaluate a metric/quality:{metric_name} whose description is {metric_desc}.
+and the score need to be done strictly follwoing the guidelines below
+<scoring_guidelines>
+{score_guide}
+<scoring_guidelines>
+
+Your output format should be strictly as mentioned in the scoring_guidelines, dont output extra text, just the score or the measuring metric should be output.
+"""
 
-        and the backstory of the character you evaluating is {backstory}
+subjective_input_sample_generation_template = """
+You are an Expert LLM Bot tester, and you are testing the following prompt:
 
-        make sure that you always create questions which will evaluate the {metric_name} very thoroughly, handling diverse cases and edge cases too. try to generate questions which will show the properites opposite/negative to {metric_name} too, so that we have questions that will break the character.
+<prompt>
+{agent_prompt}
+</prompt>
 
-        Generate only {num_q} no of questions. The output should be in a format like:
+You have to generate a set of questions or statements depending on the user request given below:
 
-        ["question1", "question2",.....]
+{user_request}
 
-        The Questions should be general and diverse, they should try to create scenarios where the character will not perform in a way described by {metric_name}
+You need to make sure that you generate different scenarios and edge cases to evaluate the above mentioned agent, based on the user request.
 
-        for example, if the metric is calmness, try to ask question which will trigger the character and make him say frustrated things.
+you need to generate {num_q} no of questions and the output format should strictly be like a list
 
-        The output should ONLY CONTAIN the LIST of QUESTIONS. NO extra text is allowed, ONLY and ONLY the list of questions in []
+OUTPUT EXAMPLE:
+
+["item1", "item2" ...., "item{num_q}"],
+
+no extra text should be generated, strictly the strings in square brackets should be returned
 """
 
-system_score = """
-You will be given the response of an AI character, you have to test it on the metric/quality {metric_name} which is described as {metric_desc}. if the response of the Ai character is very much complying with {metric_name} then score it 1, if the response is opposite to {metric_name} then score it 0.
+input_testcases_generation_template = """
+You are an expert testcase generator.
 
-VERY IMPORTANT: your answer must always be either 0 or 1, nothing else should be given, ONLY the number.
-"""
\ No newline at end of file
+You are given a prompt like:
+<prompt>
+{agent_prompt_template}
+</prompt>
+
+
+for {input_desc} in the prompt can you create {num_q} testcases for these?
+
+the output should strictly be in the format:
+
+[{json_example}, .....]
+
+All the inputs should be inside the list, in a dictionary format.
+"""
+
+objective_input_output_sample_generation_template = """
+You are an Expert LLM Bot Tester. Your task is to generate a set of input/output pairs to evaluate an LLM agent based on its prompt and a user request. Here is the agent prompt you will be testing:
+
+<agent_prompt>
+{agent_prompt}
+</agent_prompt>
+
+And here is the additional user request:
+
+<user_request>
+{user_request}
+</user_request>
+
+Your objective is to create <num_q>{num_q}</num_q> input/output pairs that thoroughly test the agent's capabilities, including various scenarios and edge cases.
+
+Important Guidelines:
+- The output for each input MUST strictly follow the instructions given in the agent_prompt.
+- Generate different scenarios and edge cases to thoroughly evaluate the agent.
+- The final output should be a list of dictionaries, with no additional text.
+
+Output Format:
+Your response should be a valid JSON list of dictionaries, where each dictionary contains an input/output pair. For example:
+
+[
+  {{"input1": "...", "output1": "..."}},
+  {{"input2": "...", "output2": "..."}},
+  ...
+]
+
+Remember: Do not include any text outside of the JSON list in your final output.
+"""
+
+LLM_as_a_judge_template = """
+You are acting as an LLM as a judge
+"""
diff --git a/server/requirements.txt b/server/requirements.txt
deleted file mode 100644
index b469483..0000000
Binary files a/server/requirements.txt and /dev/null differ
diff --git a/server/app.py b/server/run.py
similarity index 67%
rename from server/app.py
rename to server/run.py
index 488dae9..83f8581 100644
--- a/server/app.py
+++ b/server/run.py
@@ -1,4 +1,4 @@
-from app import create_app
+from server.app import create_app
 
 app = create_app()
 
diff --git a/src/static/css/auth/login.css b/src/static/css/auth/login.css
index 1c9b7ad..50d3ce2 100644
--- a/src/static/css/auth/login.css
+++ b/src/static/css/auth/login.css
@@ -1,30 +1,128 @@
-.login-container {
+:root {
+    --primary-color: #6C63FF;
+    --secondary-color: #2A2A2A;
+    --background-color: #F5F7FF;
+    --text-color: #333333;
+    --shadow-color: rgba(108, 99, 255, 0.2);
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    font-family: 'Poppins', sans-serif;
+}
+
+body {
+    background: var(--background-color);
+    min-height: 100vh;
     display: flex;
-    justify-content: center;
     align-items: center;
-    min-height: 100vh;
-    background-color: #f5f5f5;
+    justify-content: center;
+    position: relative;
+    overflow: hidden;
+}
+
+.background-shapes {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    z-index: 0;
+}
+
+.background-shapes::before,
+.background-shapes::after {
+    content: '';
+    position: absolute;
+    width: 300px;
+    height: 300px;
+    border-radius: 50%;
+    background: linear-gradient(45deg, var(--primary-color), #8B85FF);
+    opacity: 0.1;
+}
+
+.background-shapes::before {
+    top: -100px;
+    right: -100px;
+}
+
+.background-shapes::after {
+    bottom: -100px;
+    left: -100px;
+}
+
+.login-container {
+    width: 100%;
+    max-width: 400px;
+    padding: 20px;
+    z-index: 1;
 }
 
 .login-box {
     background: white;
-    padding: 2rem;
-    border-radius: 8px;
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    padding: 40px;
+    border-radius: 20px;
+    box-shadow: 0 10px 30px var(--shadow-color);
     text-align: center;
+    transform: translateY(0);
+    transition: transform 0.3s ease;
+}
+
+.login-box:hover {
+    transform: translateY(-5px);
+}
+
+.logo {
+    margin-bottom: 20px;
+}
+
+.logo img {
+    width: 80px;
+    height: auto;
+}
+
+h1 {
+    color: var(--secondary-color);
+    font-size: 28px;
+    margin-bottom: 10px;
+}
+
+.subtitle {
+    color: #666;
+    font-size: 16px;
+    margin-bottom: 30px;
 }
 
 .google-btn {
-    background: #4285f4;
-    color: white;
+    background: white;
+    color: var(--text-color);
     padding: 12px 24px;
-    border: none;
-    border-radius: 4px;
+    border: 2px solid #eee;
+    border-radius: 50px;
     cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 10px;
     font-size: 16px;
-    margin: 20px 0;
+    font-weight: 500;
+    width: 100%;
+    transition: all 0.3s ease;
 }
 
 .google-btn:hover {
-    background: #357abd;
+    background: #f8f8f8;
+    border-color: #ddd;
+    transform: translateY(-2px);
+}
+
+.google-btn img {
+    width: 20px;
+    height: 20px;
+}
+
+@media (max-width: 480px) {
+    .login-box {
+        padding: 30px 20px;
+    }
 }
\ No newline at end of file
diff --git a/src/static/css/base/_variables.css b/src/static/css/base/_variables.css
index fd0902e..079297f 100644
--- a/src/static/css/base/_variables.css
+++ b/src/static/css/base/_variables.css
@@ -1,26 +1,51 @@
 :root {
     /* Colors */
-    --primary-color: #3498db;
-    --secondary-color: #2c3e50;
-    --accent-color: #e74c3c;
-    --background-color: #ecf0f1;
-    --text-color: #34495e;
+    --primary-color: #6C63FF;
+    --secondary-color: #2A2A2A;
+    --accent-color: #8B85FF;
+    --background-color: #F5F7FF;
+    --text-color: #333333;
     --card-background: #ffffff;
-    --shadow-color: rgba(0, 0, 0, 0.1);
+    --shadow-color: rgba(108, 99, 255, 0.2);
+    --hover-color: #F0F2FF;
+
+    /* Layout-specific */
+    --sidenav-width: 280px;            
+    --header-height: 60px;           
 
     /* Typography */
-    --heading-font: 'Alfa Slab One', cursive;
-    --body-font: 'IBM Plex Mono', monospace;
+    --heading-font: 'Poppins', sans-serif;  
+    --body-font: 'Poppins', sans-serif;    
 
     /* Spacing */
-    --spacing-small: 10px;
-    --spacing-medium: 20px;
-    --spacing-large: 40px;
+    --spacing-small: 12px;             
+    --spacing-medium: 24px;             
+    --spacing-large: 40px;              
 
     /* Transitions */
-    --transition-speed: 0.3s;
+    --transition-speed: 0.3s;          
+    --transition-timing: ease;         
 
     /* Shadows */
     --shadow-default: 0 4px 6px var(--shadow-color);
     --shadow-hover: 0 6px 8px var(--shadow-color);
+    --shadow-sidenav: 2px 0 10px rgba(0, 0, 0, 0.1);
+
+    /* Border Radius */
+    --border-radius-small: 8px;
+    --border-radius-medium: 12px;   
+    --border-radius-large: 20px; 
+
+    /* Border Colors */
+    --border-color: #eee;         
+    --border-color-hover: #ddd;
+
+    /* Form specific */
+    --input-padding: 10px;
+    --input-margin: 10px;
+    --input-height-default: 38px;
+    --input-height-large: 42px;
+    --range-height: 4px;
+    --range-thumb-size: 16px;
+    --font-size-small: 0.9em;
 }
\ No newline at end of file
diff --git a/src/static/css/components/_aiagents.css b/src/static/css/components/_aiagents.css
new file mode 100644
index 0000000..7b239e6
--- /dev/null
+++ b/src/static/css/components/_aiagents.css
@@ -0,0 +1,173 @@
+/* Agent Card */
+.agent-card {
+    background: #FFFFFF;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    overflow: hidden;
+    transition: box-shadow 0.2s;
+    padding: var(--spacing-large);
+}
+
+.agent-card:hover {
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* Card Header */
+.card__header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--spacing-large);
+}
+
+.card__title {
+    margin: 0;
+    font-size: 1.25em;
+    font-weight: 600;
+    color: var(--text-color);
+}
+
+/* Prompt Section */
+.prompt-section {
+    margin-bottom: var(--spacing-large);
+}
+
+.section-title {
+    margin: 0;
+    color: var(--text-color);
+    font-size: 1em;
+    font-weight: 500;
+}
+
+.prompt-preview {
+    background: var(--background-color-dark);
+    padding: var(--spacing-medium);
+    border-radius: var(--border-radius-small);
+    font-size: 0.9em;
+    max-height: 120px;
+    overflow-y: auto;
+    color: var(--text-color-secondary);
+    font-family: monospace;
+    line-height: 1.5;
+    white-space: pre-wrap;
+}
+
+/* Variants Section */
+.variants-section {
+    margin-top: var(--spacing-large);
+}
+
+.variants-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--spacing-medium);
+    gap: var(--spacing-medium)
+}
+
+.variants-list {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-medium);
+}
+
+.variant-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: var(--spacing-small) var(--spacing-medium);
+    background: var(--background-color-light);
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--border-color);
+}
+
+.variant-item__name {
+    font-size: 0.95em;
+    color: var(--text-color);
+    font-weight: 500;
+}
+
+/* Buttons */
+.button--icon {
+    padding: var(--spacing-small);
+    min-width: unset;
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: transparent;
+}
+
+.button--icon.button--danger {
+    color: var(--danger-color);
+}
+
+.button--icon.button--danger:hover {
+    background: var(--danger-color-light);
+}
+
+/* Modal */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+    padding: var(--spacing-medium);
+}
+
+.modal .card {
+    width: 100%;
+    max-width: 500px;
+    max-height: 90vh;
+    overflow-y: auto;
+    background: #FFFFFF;
+    border-radius: var(--border-radius);
+    box-shadow: 0 4px 12px #00000026;
+}
+
+.modal .card__title {
+    padding: var(--spacing-medium);
+    border-bottom: 1px solid var(--border-color);
+    margin: 0;
+    background: #FFFFFF;
+    font-size: 1.1em;
+    font-weight: 500;
+}
+
+.modal .card__content {
+    padding: var(--spacing-medium);
+    background: #FFFFFF;
+}
+
+.modal .form__input-group {
+    margin-bottom: var(--spacing-medium);
+}
+
+.modal .card__actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: var(--spacing-small);
+    padding: var(--spacing-medium);
+    border-top: 1px solid var(--border-color);
+    background: #FFFFFF;
+}
+
+/* Empty State */
+.empty-state {
+    text-align: center;
+    padding: var(--spacing-large);
+    color: var(--text-color-secondary);
+}
+
+.empty-state i {
+    font-size: 48px;
+    margin-bottom: var(--spacing-medium);
+    opacity: 0.5;
+}
\ No newline at end of file
diff --git a/src/static/css/components/_button.css b/src/static/css/components/_button.css
new file mode 100644
index 0000000..dea67d9
--- /dev/null
+++ b/src/static/css/components/_button.css
@@ -0,0 +1,33 @@
+.button {
+    padding: 12px 24px;
+    border-radius: 8px;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    font-weight: 500;
+    font-family: var(--body-font);
+    font-size: 14px;
+    line-height: 1;
+    transition: all var(--transition-speed) var(--transition-timing);
+}
+
+.button .material-icons {
+    font-size: 20px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.button--primary {
+    background: var(--primary-color);
+    color: white;
+}
+
+.button--primary:hover {
+    background: var(--accent-color);
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-default);
+}
\ No newline at end of file
diff --git a/src/static/css/components/_cards.css b/src/static/css/components/_cards.css
index 749cd89..c28dfb2 100644
--- a/src/static/css/components/_cards.css
+++ b/src/static/css/components/_cards.css
@@ -43,6 +43,16 @@
     border-radius: 4px;
     cursor: pointer;
     transition: background-color var(--transition-speed) ease;
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    line-height: 1;
+}
+
+.card__button--delete .material-icons {
+    font-size: 16px;
+    display: inline-flex;
+    align-items: center;
 }
 
 .card__button--delete:hover {
@@ -53,4 +63,18 @@
     display: grid;
     grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
     gap: var(--spacing-medium);
+}
+
+@media screen and (max-width: 768px) {
+    .card-grid {
+        display: grid;
+        grid-template-columns: 280px;
+        gap: var(--spacing-medium);
+        padding-left: 20px;
+    }
+
+    .card {
+        width: 100%;
+        margin: 0;
+    }
 }
\ No newline at end of file
diff --git a/src/static/css/components/_dataset.css b/src/static/css/components/_dataset.css
new file mode 100644
index 0000000..c11b397
--- /dev/null
+++ b/src/static/css/components/_dataset.css
@@ -0,0 +1,188 @@
+/* Editor Layout */
+.dataset-editor {
+    padding: var(--spacing-medium);
+    max-width: 1200px;
+    margin: 0 auto;
+}
+
+.editor-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--spacing-medium);
+}
+
+.editor-row {
+    display: flex;
+    gap: var(--spacing-medium);
+    margin-bottom: var(--spacing-medium);
+}
+
+/* Form Elements */
+.dataset-name,
+.agent-select {
+    flex: 1;
+}
+
+/* Using form styles for select */
+.agent-select select {
+    width: 100%;
+    height: var(--input-height-default);
+    padding: var(--input-padding);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+    background-color: var(--card-background);
+    font-family: var(--body-font);
+}
+
+/* Sample Controls */
+.sample-controls {
+    display: flex;
+    gap: var(--spacing-small);
+    margin-bottom: var(--spacing-medium);
+    align-items: center;
+    background: var(--card-background);
+    padding: var(--spacing-medium);
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--border-color);
+}
+
+#sampleCount {
+    width: 150px;
+    height: var(--input-height-default);
+    padding: var(--input-padding);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+    font-family: var(--body-font);
+}
+
+#addSample {
+    margin-left: auto;
+}
+
+/* Sample Cards */
+.sample-card {
+    background: var(--card-background);
+    border-radius: var(--border-radius-small);
+    margin-bottom: var(--spacing-medium);
+    box-shadow: var(--shadow-default);
+    border: 1px solid var(--border-color);
+}
+
+.sample-header {
+    padding: var(--spacing-small) var(--spacing-medium);
+    cursor: pointer;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--background-color);
+    border-bottom: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small) var(--border-radius-small) 0 0;
+}
+
+.sample-content {
+    padding: var(--spacing-medium);
+}
+
+/* Sample Inputs */
+.sample-inputs {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-medium);
+}
+
+.free-variables {
+    background: var(--background-color);
+    padding: var(--spacing-medium);
+    border-radius: var(--border-radius-small);
+    border: 1px solid var(--border-color);
+}
+
+.free-variables h4 {
+    margin-bottom: var(--spacing-small);
+    color: var(--text-color);
+    font-family: var(--heading-font);
+}
+
+/* Using form styles for inputs and textareas */
+.form-group textarea {
+    width: 100%;
+    resize: vertical;
+    min-height: 100px;
+    padding: var(--input-padding);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+    font-family: var(--body-font);
+    background-color: var(--card-background);
+}
+
+.form-group input {
+    width: 100%;
+    height: var(--input-height-default);
+    padding: var(--input-padding);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+    font-family: var(--body-font);
+    background-color: var(--card-background);
+}
+
+/* Messages */
+.no-agent-message {
+    color: var(--secondary-color);
+    text-align: center;
+    padding: var(--spacing-small);
+}
+
+/* Editor Actions */
+.editor-actions {
+    display: flex;
+    justify-content: flex-end;
+    margin-top: var(--spacing-medium);
+}
+
+/* Dataset Cards in List View */
+.dataset-card {
+    background: var(--card-background);
+    border-radius: var(--border-radius-small);
+    padding: var(--spacing-medium);
+    margin-bottom: var(--spacing-medium);
+    border: 1px solid var(--border-color);
+    box-shadow: var(--shadow-default);
+}
+
+.card__title {
+    margin: 0 0 var(--spacing-small);
+    color: var(--text-color);
+    font-size: 1.25rem;
+    font-family: var(--heading-font);
+}
+
+.card__samples {
+    color: var(--secondary-color);
+    font-size: var(--font-size-small);
+    margin-bottom: var(--spacing-medium);
+}
+
+.card__actions {
+    display: flex;
+    gap: var(--spacing-small);
+}
+
+.card__button--edit,
+.card__button--delete {
+    display: inline-flex;
+    align-items: center;
+    gap: calc(var(--spacing-small) / 2);
+    padding: calc(var(--spacing-small) / 2);
+    border-radius: var(--border-radius-small);
+    font-size: var(--font-size-small);
+}
+
+.card__button--edit {
+    background: var(--background-color);
+}
+
+.card__button--delete {
+    background-color: var(--accent-color);
+    color: var(--card-background);
+}
\ No newline at end of file
diff --git a/src/static/css/components/_forms.css b/src/static/css/components/_forms.css
index 8d4191b..209f65c 100644
--- a/src/static/css/components/_forms.css
+++ b/src/static/css/components/_forms.css
@@ -1,99 +1,135 @@
-/* Form Elements */
 .form__input {
     width: 100%;
-    padding: 10px;
-    margin-bottom: 10px;
-    border: 1px solid #bdc3c7;
-    border-radius: 4px;
+    padding: var(--input-padding);
+    margin-bottom: var(--input-margin);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
     box-sizing: border-box;
     font-family: var(--body-font);
 }
 
 .form__label {
     display: block;
-    margin-bottom: 15px;
+    margin-bottom: var(--spacing-small);
     font-family: var(--body-font);
 }
 
 .form__range-container {
     display: flex;
     align-items: center;
-    margin-top: 5px;
+    margin-top: var(--spacing-small);
 }
 
 .form__range {
+    -webkit-appearance: none;
+    appearance: none;
     width: calc(100% - 60px);
-    margin-right: 10px;
+    margin-right: var(--spacing-small);
     vertical-align: middle;
+    height: var(--range-height);
+    background: var(--primary-color);
+    border-radius: calc(var(--range-height) / 2);
+}
+
+.form__range::-webkit-slider-runnable-track {
+    height: var(--range-height);
+    background: var(--primary-color);
+    border-radius: calc(var(--range-height) / 2);
+}
+
+.form__range::-moz-range-track {
+    height: var(--range-height);
+    border-radius: calc(var(--range-height) / 2);
+}
+
+.form__range::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: var(--range-thumb-size);
+    height: var(--range-thumb-size);
+    margin-top: calc((var(--range-height) - var(--range-thumb-size)) / 2);
+    background: var(--primary-color);
+    border-radius: 50%;
+    cursor: pointer;
+    transition: background-color var(--transition-speed) var(--transition-timing);
+}
+
+.form__range::-moz-range-thumb {
+    width: var(--range-thumb-size);
+    height: var(--range-thumb-size);
+    background: var(--primary-color);
+    border: none;
+    border-radius: 50%;
+    cursor: pointer;
+    transition: background-color var(--transition-speed) var(--transition-timing);
 }
 
 .form__range-value {
     display: inline-block;
-    width: 50px;
+    width: 50px; /* Specific to this element */
     text-align: center;
-    background-color: #f0f0f0;
-    padding: 5px;
-    border-radius: 4px;
-    font-size: 0.9em;
+    background: var(--card-background);
+    padding: var(--spacing-small);
+    border-radius: var(--border-radius-small);
+    font-size: var(--font-size-small);
+    border: 1px solid var(--border-color);
+    color: var(--text-color);
 }
 
-/* Buttons */
 .button {
     border: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius-small);
     cursor: pointer;
-    transition: all var(--transition-speed) ease;
+    transition: all var(--transition-speed) var(--transition-timing);
 }
 
 .button--primary {
     background-color: var(--primary-color);
-    color: white;
-    padding: 10px 15px;
-    font-size: 0.9em;
+    color: var(--card-background);
+    padding: var(--input-padding) var(--spacing-small);
+    font-size: var(--font-size-small);
 }
 
 .button--primary:hover {
-    background-color: #2980b9;
+    background-color: var(--accent-color);
     transform: translateY(-2px);
 }
 
-/* Evaluation Controls */
 .eval-controls {
     display: flex;
     gap: var(--spacing-small);
     align-items: center;
-    margin-bottom: 15px;
+    margin-bottom: var(--spacing-small);
 }
 
 .eval-controls .form__input {
     flex: 1;
     margin-bottom: 0;
-    height: 38px;
+    height: var(--input-height-default);
 }
 
 .eval-controls .button {
     white-space: nowrap;
-    height: 38px;
-    padding: 10px 15px;
-    font-size: 0.9em;
+    height: var(--input-height-default);
+    padding: var(--input-padding) var(--spacing-small);
+    font-size: var(--font-size-small);
 }
 
-/* Update select styling to match inputs */
 select.form__input {
     appearance: none;
     background-image: url("data:image/svg+xml,...");
     background-repeat: no-repeat;
-    background-position: right 8px center;
-    padding-right: 30px;
-    height: 38px;
+    background-position: right var(--spacing-small) center;
+    padding-right: 30px; /* Specific to accommodate the dropdown arrow */
+    height: var(--input-height-large);
 }
 
 .evaluation-result {
     background-color: var(--card-background);
     border-left: 4px solid var(--primary-color);
-    padding: 15px;
-    margin-bottom: 15px;
-    border-radius: 4px;
+    padding: var(--spacing-small);
+    margin-bottom: var(--spacing-small);
+    border-radius: var(--border-radius-small);
     box-shadow: var(--shadow-default);
 }
 
@@ -107,7 +143,7 @@ select.form__input {
 .error {
     color: var(--accent-color);
     font-weight: bold;
-    padding: 10px;
-    background-color: #fadbd8;
-    border-radius: 4px;
+    padding: var(--input-padding);
+    background-color: #fadbd8; /* Specific error color */
+    border-radius: var(--border-radius-small);
 }
\ No newline at end of file
diff --git a/src/static/css/components/_header.css b/src/static/css/components/_header.css
deleted file mode 100644
index 3b24b5a..0000000
--- a/src/static/css/components/_header.css
+++ /dev/null
@@ -1,25 +0,0 @@
-.header-content {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 10px;
-}
-
-.user-info {
-    display: flex;
-    align-items: center;
-}
-
-button {
-    background-color: #4285f4;
-    color: white;
-    border: none;
-    padding: 5px 10px;
-    border-radius: 4px;
-    cursor: pointer;
-    margin-left: 10px;
-}
-
-button:hover {
-    background-color: #357abd;
-}
\ No newline at end of file
diff --git a/src/static/css/components/_layout.css b/src/static/css/components/_layout.css
new file mode 100644
index 0000000..215d527
--- /dev/null
+++ b/src/static/css/components/_layout.css
@@ -0,0 +1,55 @@
+.app-container {
+    display: flex;
+    min-height: 100vh;
+    font-family: var(--body-font);
+}
+
+.main-content {
+    margin-left: var(--sidenav-width);
+    padding: var(--spacing-large);
+    width: calc(100% - var(--sidenav-width));
+    background: var(--background-color);
+    overflow-x: hidden;
+}
+
+.content-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    margin-bottom: var(--spacing-large);
+}
+
+.content-header h1 {
+    color: var(--secondary-color);
+    font-family: var(--heading-font);
+    font-size: 24px;
+}
+
+@media screen and (max-width: 768px) {
+    .main-content {
+        margin-left: 0;
+        padding: 20px;
+        padding-left: 60px;
+        width: 100%;
+        box-sizing: border-box;
+    }
+
+    .content-header {
+        padding: 0 16px;
+        margin-top: 10px;
+    }
+
+    .content-header h1 {
+        margin-left: 10px;
+    }
+}
+
+.tab-content {
+    display: none;
+    width: 100%;
+    overflow-x: hidden;
+}
+
+.tab-content.active {
+    display: block;
+}
\ No newline at end of file
diff --git a/src/static/css/components/_panel.css b/src/static/css/components/_panel.css
deleted file mode 100644
index da7b894..0000000
--- a/src/static/css/components/_panel.css
+++ /dev/null
@@ -1,64 +0,0 @@
-/* Sliding Panel */
-.panel {
-    position: fixed;
-    top: 0;
-    right: -100%;
-    width: 70%;
-    height: 100%;
-    background-color: var(--card-background);
-    box-shadow: -2px 0 5px var(--shadow-color);
-    z-index: 1000;
-    overflow: scroll;
-    padding: 40px;
-    visibility: hidden;
-}
-
-.panel--open {
-    right: 0;
-    visibility: visible;
-    transition: right var(--transition-speed) ease-in-out;
-}
-
-.panel__title {
-    font-family: var(--heading-font);
-    margin-bottom: var(--spacing-medium);
-    padding-bottom: 10px;
-    border-bottom: 2px solid var(--primary-color);
-}
-
-.panel__close-btn {
-    position: absolute;
-    top: var(--spacing-medium);
-    right: var(--spacing-medium);
-    background: none;
-    border: none;
-    font-size: 1.5em;
-    cursor: pointer;
-    color: var(--text-color);
-}
-
-.panel__save-btn {
-    margin-bottom: 50px;
-}
-
-/* Overlay */
-.overlay {
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background-color: rgba(0, 0, 0, 0.5);
-    backdrop-filter: blur(5px);
-    z-index: 999;
-    display: none;
-}
-
-.overlay--active {
-    display: block;
-}
-
-/* Body modifier when panel is open */
-.body--panel-open {
-    overflow: hidden;
-}
\ No newline at end of file
diff --git a/src/static/css/components/_playground.css b/src/static/css/components/_playground.css
new file mode 100644
index 0000000..3fa5553
--- /dev/null
+++ b/src/static/css/components/_playground.css
@@ -0,0 +1,401 @@
+/* Existing Container Styles */
+.playground-container {
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    height: calc(100vh - var(--spacing-large) * 2 - 60px);
+    overflow-y: auto;
+    width: 100%;
+    overflow-x: hidden;
+}
+
+/* Prompts Section */
+.prompts-scroll-container {
+    width: 100%;
+    overflow-x: auto;
+    max-width: calc(100vw - var(--sidenav-width) - var(--spacing-large) * 2 - 40px);
+    margin-bottom: 20px;
+}
+
+.prompts-container {
+    display: flex;
+    gap: 1rem;
+    width: 100%;
+}
+
+/* Prompt Card Styles */
+.prompt-card {
+    flex: 1 0 330px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 1rem;
+    background: #fff;
+    display: flex;
+    flex-direction: column;
+}
+
+.save-prompt {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.save-prompt i {
+    font-size: 1.2rem;
+}
+
+.prompts-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+}
+
+.prompt-header {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-small);
+    margin-bottom: var(--spacing-small);
+}
+
+.prompt-header:not(:first-child) {
+    margin-top: var(--spacing-medium);
+}
+
+.prompt-header label {
+    white-space: nowrap;
+    font-weight: 500;
+    font-size: 0.9rem;
+}
+
+.prompt-header select {
+    flex: 0 1 140px;
+    font-size: 0.8rem;
+    padding: 2px 4px;
+    height: 24px;
+    margin-left: auto;
+    margin-bottom: 0;
+    text-align: center;
+}
+
+.prompt-card__footer {
+    display: flex;
+    gap: 1rem;
+    margin-top: 1rem;
+    align-items: center;
+}
+
+.agent-name {
+    flex: 1;
+    max-width: 300px;
+    margin-bottom: 0;
+}
+
+.prompt-actions {
+    display: flex;
+    justify-content: flex-end;
+    margin: var(--spacing-medium) 0;
+}
+
+.user-prompt-template {
+    width: 100%;
+    min-height: var(--input-height-large);
+    resize: vertical;
+}
+
+/* Button Styles */
+.button--icon {
+    padding: 4px;
+    min-width: auto;
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #666;
+}
+
+.button--icon:hover {
+    color: #ff4444;
+}
+
+.button--icon.settings-prompt:hover {
+    color: var(--color-primary);
+}
+
+/* Prompt Template */
+.prompt-template {
+    min-height: 100px;
+    font-family: monospace;
+    padding: 10px;
+    resize: vertical;
+    width: 100%;
+}
+
+/* Dynamic Inputs Section */
+.dynamic-inputs-section {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.input-group {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: var(--spacing-small);
+    margin-bottom: var(--spacing-small);
+}
+
+.input-group label {
+    min-width: 100px;
+    font-size: 0.9rem;
+    color: var(--text-color);
+}
+
+.input-group__content {
+    display: flex;
+    flex: 1;
+    gap: var(--spacing-small);
+    align-items: center;
+}
+
+.input-group__content .form__input {
+    flex: 1;
+    margin-bottom: 0;
+}
+
+.checkbox-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    margin-left: 4px;
+}
+
+.variable-persistence {
+    margin: 0;
+    width: 16px;
+    height: 16px;
+    cursor: pointer;
+}
+
+.checkbox-label {
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+    cursor: pointer;
+    margin: 0;
+    user-select: none;
+}
+
+/* Controls Section */
+.controls-section {
+    display: flex;
+    gap: 10px;
+    flex-wrap: wrap;
+}
+
+/* Evaluation Results */
+.evaluation-result {
+    background: #f5f5f5;
+    padding: 15px;
+    border-radius: 4px;
+    margin-top: 20px;
+}
+
+.evaluation-result pre {
+    background: #fff;
+    padding: 10px;
+    border-radius: 4px;
+    overflow-x: auto;
+}
+
+/* Settings Popup Styles */
+.settings-popup {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    display: none;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.settings-content {
+    background: white;
+    padding: 2rem;
+    border-radius: var(--border-radius);
+    width: 400px;
+    max-width: 90vw;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+}
+
+.settings-form {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+    margin: 1.5rem 0;
+}
+
+.form-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.form-group label {
+    font-weight: 500;
+    color: var(--text-color);
+}
+
+/* Range Input Styling */
+.range-with-value {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.temperature-value {
+    min-width: 2.5em;
+    text-align: right;
+    color: var(--text-secondary);
+}
+
+/* Settings Actions */
+.settings-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 1rem;
+    margin-top: 1.5rem;
+    border-top: 1px solid var(--border-color);
+    padding-top: 1.5rem;
+}
+
+.chat-container {
+    margin-top: var(--spacing-medium);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+}
+
+.chat-messages {
+    max-height: 300px;
+    overflow-y: auto;
+    padding: var(--spacing-medium);
+}
+
+.chat-message {
+    display: flex;
+    gap: var(--spacing-small);
+    margin-bottom: var(--spacing-medium);
+    align-items: center;
+}
+
+.chat-message__avatar {
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    background: var(--secondary-color);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    border: 2px solid var(--secondary-color);
+}
+
+.chat-message__avatar i {
+    font-size: 18px;
+    color: var(--secondary-color);
+}
+
+.chat-message__content {
+    background: var(--background-color);
+    padding: var(--spacing-small);
+    border-radius: var(--border-radius-small);
+    flex: 1;
+    line-height: 1.4;
+}
+
+.chat-input-container {
+    display: flex;
+    gap: var(--spacing-small);
+    padding: var(--spacing-medium);
+    border-top: 1px solid var(--border-color);
+    align-items: flex-start;
+}
+
+.chat-input-container .user-prompt {
+    flex: 1;
+    resize: none;
+    min-height: var(--input-height-default);
+    padding: var(--input-padding);
+    border-radius: var(--border-radius-small);
+    font-family: var(--body-font);
+}
+
+.chat-input-container .button--primary {
+    height: var(--input-height-default);
+    width: var(--input-height-default);
+    padding: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: var(--border-radius-small);
+}
+
+.chat-message--user .chat-message__avatar {
+    border-color: var(--primary-color);
+}
+
+.chat-message--assistant .chat-message__avatar {
+    border-color: var(--accent-color);
+}
+
+.chat-message--user .chat-message__avatar i {
+    color: var(--primary-color);
+}
+
+.chat-message--assistant .chat-message__avatar i {
+    color: var(--accent-color);
+}
+
+.agent-selector {
+    position: relative;
+    display: inline-block;
+    margin-left: auto;
+}
+
+.agent-menu {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    background: white;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    z-index: 1000;
+    min-width: 200px;
+}
+
+.agent-item {
+    padding: 8px 12px;
+    cursor: pointer;
+}
+
+.agent-item:hover {
+    background: #f5f5f5;
+}
+
+.agent-submenu {
+    margin-top: 4px;
+    border-left: 2px solid #eee;
+}
+
+.agent-action {
+    padding: 8px 12px 8px 24px;
+    cursor: pointer;
+}
+
+.agent-action:hover {
+    background: #f0f0f0;
+}
\ No newline at end of file
diff --git a/src/static/css/components/_sidenav.css b/src/static/css/components/_sidenav.css
new file mode 100644
index 0000000..7346ea4
--- /dev/null
+++ b/src/static/css/components/_sidenav.css
@@ -0,0 +1,113 @@
+.sidenav {
+    width: var(--sidenav-width);
+    background: var(--card-background);
+    box-shadow: var(--shadow-sidenav);
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    height: 100vh;
+}
+
+.sidenav__user {
+    padding: 24px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.sidenav__user img {
+    width: 48px;
+    height: 48px;
+    border-radius: 50%;
+    object-fit: cover;
+}
+
+.sidenav__user span {
+    font-weight: 500;
+    color: var(--secondary-color);
+}
+
+.sidenav__menu {
+    flex-grow: 1;
+    padding: var(--spacing-medium) 0;
+}
+
+.sidenav__item {
+    display: flex;
+    align-items: center;
+    padding: var(--spacing-small) var(--spacing-medium);
+    color: var(--text-color);
+    text-decoration: none;
+    transition: all var(--transition-speed) var(--transition-timing);
+    gap: var(--spacing-small);
+}
+
+.sidenav__item:hover {
+    background: var(--hover-color);
+}
+
+.sidenav__item.active {
+    background: var(--hover-color);
+    color: var(--primary-color);
+    border-left: 4px solid var(--primary-color);
+}
+
+.sidenav__footer {
+    padding: var(--spacing-medium);
+    border-top: 1px solid var(--border-color);
+}
+
+.sidenav__signout {
+    width: 100%;
+    padding: var(--spacing-small);
+    background: none;
+    border: 2px solid var(--border-color);
+    border-radius: var(--border-radius-small);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--spacing-small);
+    transition: all var(--transition-speed) var(--transition-timing);
+    color: var(--text-color);
+}
+
+.sidenav__signout:hover {
+    background: var(--hover-color);
+    border-color: var(--border-color-hover);
+}
+
+/* Mobile styles */
+@media screen and (max-width: 768px) {
+    .sidenav {
+        position: fixed;
+        left: -100%;
+        z-index: 1000;
+        transition: left 0.3s ease;
+    }
+
+    .sidenav.active {
+        left: 0;
+    }
+
+    /* Add hamburger menu button */
+    .menu-toggle {
+        display: block;
+        position: absolute;
+        top: var(--spacing-medium);
+        left: var(--spacing-medium);
+        z-index: 999;
+        background: var(--primary-color);
+        color: white;
+        border: none;
+        border-radius: 4px;
+        padding: var(--spacing-small);
+        cursor: pointer;
+        margin-top: 6px;
+    }
+
+    .menu-toggle .material-icons {
+        font-size: 18px;
+    }
+}
diff --git a/src/static/css/components/_toast.css b/src/static/css/components/_toast.css
new file mode 100644
index 0000000..88531ab
--- /dev/null
+++ b/src/static/css/components/_toast.css
@@ -0,0 +1,26 @@
+.toast {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    padding: 12px 24px;
+    background: #4CAF50;
+    color: white;
+    border-radius: 4px;
+    box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+    opacity: 0;
+    transform: translateY(100%);
+    transition: all 0.3s ease;
+}
+
+.toast--visible {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.toast--success {
+    background: #4CAF50;
+}
+
+.toast--error {
+    background: #f44336;
+}
\ No newline at end of file
diff --git a/src/static/css/main.css b/src/static/css/main.css
index ef4b024..a147449 100644
--- a/src/static/css/main.css
+++ b/src/static/css/main.css
@@ -2,5 +2,10 @@
 @import 'base/_global.css';
 @import 'components/_cards.css';
 @import 'components/_forms.css';
-@import 'components/_panel.css';
-@import 'components/_header.css';
\ No newline at end of file
+@import 'components/_layout.css';
+@import 'components/_sidenav.css';
+@import 'components/_button.css';
+@import 'components/_playground.css';
+@import 'components/_dataset.css';
+@import 'components/_toast.css';
+@import 'components/_aiagents.css';
\ No newline at end of file
diff --git a/src/static/images/default-avatar.png b/src/static/images/default-avatar.png
new file mode 100644
index 0000000..2b587a6
Binary files /dev/null and b/src/static/images/default-avatar.png differ
diff --git a/src/static/images/google-icon.png b/src/static/images/google-icon.png
new file mode 100644
index 0000000..35dc31d
Binary files /dev/null and b/src/static/images/google-icon.png differ
diff --git a/src/static/images/logo.png b/src/static/images/logo.png
new file mode 100644
index 0000000..fa71d7a
Binary files /dev/null and b/src/static/images/logo.png differ
diff --git a/src/static/js/api/aiAgents.js b/src/static/js/api/aiAgents.js
new file mode 100644
index 0000000..fefdf76
--- /dev/null
+++ b/src/static/js/api/aiAgents.js
@@ -0,0 +1,38 @@
+export const AiAgentAPI = {
+    fetchAll: async () => {
+        const response = await fetch('/api/ai_agents');
+        return response.json();
+    },
+
+    create: async (agentData) => {
+        const response = await fetch('/api/ai_agents', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify(agentData)
+        });
+        return response.json();
+    },
+
+    delete: async (id) => {
+        const response = await fetch(`/api/ai_agents/${id}`, {
+            method: 'DELETE'
+        });
+        return response.json();
+    },
+
+    addVariant: async (agentId, variantData) => {
+        const response = await fetch(`/api/ai_agents/${agentId}/variants`, {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify(variantData)
+        });
+        return response.json();
+    },
+
+    deleteVariant: async (agentId, variantId) => {
+        const response = await fetch(`/api/ai_agents/${agentId}/variants/${variantId}`, {
+            method: 'DELETE'
+        });
+        return response.json();
+    }
+};
\ No newline at end of file
diff --git a/src/static/js/api/characters.js b/src/static/js/api/characters.js
deleted file mode 100644
index 9dc90a4..0000000
--- a/src/static/js/api/characters.js
+++ /dev/null
@@ -1,22 +0,0 @@
-export const CharacterAPI = {
-    fetchAll: async () => {
-        const response = await fetch('/api/characters');
-        return response.json();
-    },
-
-    create: async (characterData) => {
-        const response = await fetch('/api/characters', {
-            method: 'POST',
-            headers: {'Content-Type': 'application/json'},
-            body: JSON.stringify(characterData)
-        });
-        return response.json();
-    },
-
-    delete: async (id) => {
-        const response = await fetch(`/api/characters/${id}`, {
-            method: 'DELETE'
-        });
-        return response.json();
-    }
-};
\ No newline at end of file
diff --git a/src/static/js/api/datasets.js b/src/static/js/api/datasets.js
index 808bed1..b3e03bb 100644
--- a/src/static/js/api/datasets.js
+++ b/src/static/js/api/datasets.js
@@ -1,4 +1,15 @@
 export const DatasetAPI = {
+    fetchById: async (id) => {
+        const response = await fetch(`/api/datasets/${id}`, {
+            method: 'GET',
+            headers: {'Content-Type': 'application/json'}
+        });
+        if (!response.ok) {
+            throw new Error('Failed to fetch dataset');
+        }
+        return response.json();
+    },
+
     fetchAll: async () => {
         const response = await fetch('/api/datasets');
         return response.json();
@@ -10,6 +21,21 @@ export const DatasetAPI = {
             headers: {'Content-Type': 'application/json'},
             body: JSON.stringify(datasetData)
         });
+        if (!response.ok) {
+            throw new Error('Failed to create dataset');
+        }
+        return response.json();
+    },
+
+    update: async (id, datasetData) => {
+        const response = await fetch(`/api/datasets/${id}`, {
+            method: 'PUT',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify(datasetData)
+        });
+        if (!response.ok) {
+            throw new Error('Failed to update dataset');
+        }
         return response.json();
     },
 
@@ -21,11 +47,14 @@ export const DatasetAPI = {
     },
 
     generateQuestions: async (data) => {
-        const response = await fetch('/api/generate_questions', {
+        const response = await fetch('/api/datasets/generate_questions', {
             method: 'POST',
             headers: {'Content-Type': 'application/json'},
             body: JSON.stringify(data)
         });
+        if (!response.ok) {
+            throw new Error('Failed to generate questions');
+        }
         const result = await response.json();
         return result.questions;
     }
diff --git a/src/static/js/components/agents/agentCard.js b/src/static/js/components/agents/agentCard.js
new file mode 100644
index 0000000..5a4f443
--- /dev/null
+++ b/src/static/js/components/agents/agentCard.js
@@ -0,0 +1,159 @@
+import { UIHelper } from '../../utils/uiHelper.js';
+
+export class AgentCardRenderer {
+    constructor(onVariantCreate, onAgentDelete, onVariantDelete) {
+        this.onVariantCreate = onVariantCreate;
+        this.onAgentDelete = onAgentDelete;
+        this.onVariantDelete = onVariantDelete;
+    }
+
+    createCard(id, data) {
+        const card = document.createElement('div');
+        card.className = 'card agent-card';
+        
+        card.innerHTML = this.generateCardHTML(id, data);
+        this.attachEventListeners(card, id, data);
+        
+        return card;
+    }
+
+    generateCardHTML(id, data) {
+        return `
+            <div class="card__header">
+                <h3 class="card__title">${data.name}</h3>
+                <button class="button button--icon button--danger" data-id="${id}" title="Delete Agent">
+                    <i class="material-icons">delete</i>
+                </button>
+            </div>
+            
+            <div class="card__content">
+                ${this.generatePromptSection(data)}
+                ${this.generateVariantsSection(id, data)}
+            </div>
+        `;
+    }
+
+    generatePromptSection(data) {
+        return `
+            <div class="prompt-section">
+                <h4 class="section-title">Prompt Template</h4>
+                <pre class="prompt-preview">${data.prompt[0].content}</pre>
+            </div>
+        `;
+    }
+
+    generateVariantsSection(id, data) {
+        const variantsList = this.generateVariantsList(data.variants);
+        
+        return `
+            <div class="variants-section">
+                <div class="variants-header">
+                    <h4 class="section-title">Variants</h4>
+                    <button class="button button--secondary create-variant" data-id="${id}">
+                        <i class="material-icons">add</i> New Variant
+                    </button>
+                </div>
+                <div class="variants-list">
+                    ${variantsList}
+                </div>
+            </div>
+        `;
+    }
+
+    generateVariantsList(variants) {
+        if (!variants) return '';
+        
+        return Object.entries(variants)
+            .map(([variantId, variant]) => `
+                <div class="variant-item">
+                    <span class="variant-item__name">${variant.name}</span>
+                    <button class="button button--icon button--danger" 
+                        data-variant-id="${variantId}" 
+                        title="Delete Variant">
+                        <i class="material-icons">delete</i>
+                    </button>
+                </div>
+            `).join('');
+    }
+
+    attachEventListeners(card, id, data) {
+        card.querySelector('.create-variant').onclick = () => this.showVariantForm(id, data);
+        card.querySelector('[data-id]').onclick = () => this.onAgentDelete(id);
+        
+        card.querySelectorAll('[data-variant-id]').forEach(btn => {
+            btn.onclick = (e) => {
+                e.stopPropagation();
+                this.onVariantDelete(id, btn.dataset.variantId);
+            };
+        });
+    }
+
+    showVariantForm(agentId, agentData) {
+        if (!this.validateVariantCreation(agentData)) return;
+        
+        const modal = this.createVariantModal(agentData.included_variables);
+        document.body.appendChild(modal);
+        
+        this.setupModalEventListeners(modal, agentId);
+    }
+
+    validateVariantCreation(agentData) {
+        if (!agentData.included_variables?.length) {
+            UIHelper.showAlert('No variables are marked for inclusion in variants. Please edit the base agent and mark variables to include.');
+            return false;
+        }
+        return true;
+    }
+
+    createVariantModal(includedVariables) {
+        const modal = document.createElement('div');
+        modal.className = 'modal';
+        modal.innerHTML = `
+            <div class="card">
+                <h3 class="card__title">Create Variant</h3>
+                <form class="card__content">
+                    <div class="form__input-group">
+                        <label class="form__label">Variant Name</label>
+                        <input type="text" class="form__input" placeholder="Enter variant name" required>
+                    </div>
+                    ${this.generateVariableInputs(includedVariables)}
+                    <div class="card__actions">
+                        <button type="button" class="button button--secondary modal-close">Cancel</button>
+                        <button type="submit" class="button button--primary">Save Variant</button>
+                    </div>
+                </form>
+            </div>
+        `;
+        return modal;
+    }
+
+    generateVariableInputs(variables) {
+        return variables.map(variable => `
+            <div class="form__input-group">
+                <label class="form__label">${variable}</label>
+                <input type="text" class="form__input" name="${variable}" required>
+            </div>
+        `).join('');
+    }
+
+    setupModalEventListeners(modal, agentId) {
+        const form = modal.querySelector('form');
+        
+        form.onsubmit = async (e) => {
+            e.preventDefault();
+            const variantName = form.querySelector('input').value;
+            const variables = {};
+            form.querySelectorAll('[name]').forEach(input => {
+                variables[input.name] = input.value;
+            });
+            
+            await this.onVariantCreate(agentId, variantName, variables);
+            modal.remove();
+        };
+
+        modal.querySelector('.modal-close').onclick = () => modal.remove();
+        modal.onclick = (e) => {
+            if (e.target === modal) modal.remove();
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/agents/agentMenu.js b/src/static/js/components/agents/agentMenu.js
new file mode 100644
index 0000000..32f9d32
--- /dev/null
+++ b/src/static/js/components/agents/agentMenu.js
@@ -0,0 +1,46 @@
+export class AgentMenu {
+    constructor(parentElement, onAgentSelect) {
+        this.element = parentElement.querySelector('.agent-menu');
+        this.onAgentSelect = onAgentSelect;
+    }
+
+    updateAgentSelect(agents) {
+        this.element.innerHTML = Object.entries(agents).map(([id, agent]) => `
+            <div class="agent-item" data-id="${id}">
+                <span>${agent.name}</span>
+                <div class="agent-submenu" style="display: none;">
+                    <div class="agent-action" data-action="load:${id}">Load Base Agent</div>
+                    ${agent.variants ? Object.entries(agent.variants).map(([vId, variant]) => 
+                        `<div class="agent-action" data-action="variant:${id}:${vId}">${variant.name}</div>`
+                    ).join('') : ''}
+                </div>
+            </div>
+        `).join('');
+    }
+
+    toggle() {
+        this.element.style.display = this.element.style.display === 'none' ? 'block' : 'none';
+    }
+
+    close() {
+        this.element.style.display = 'none';
+        this.element.querySelectorAll('.agent-submenu').forEach(submenu => {
+            submenu.style.display = 'none';
+        });
+    }
+
+    async handleClick(e) {
+        const agentItem = e.target.closest('.agent-item');
+        const actionItem = e.target.closest('.agent-action');
+
+        if (agentItem && !actionItem) {
+            const submenu = agentItem.querySelector('.agent-submenu');
+            submenu.style.display = submenu.style.display === 'none' ? 'block' : 'none';
+            return;
+        }
+
+        if (actionItem && this.onAgentSelect) {
+            await this.onAgentSelect(actionItem.dataset.action);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/agents/aiAgentManager.js b/src/static/js/components/agents/aiAgentManager.js
new file mode 100644
index 0000000..61b9369
--- /dev/null
+++ b/src/static/js/components/agents/aiAgentManager.js
@@ -0,0 +1,120 @@
+import { AiAgentAPI } from '../../api/aiAgents.js';
+import { UIHelper } from '../../utils/uiHelper.js';
+import { AgentCardRenderer } from './agentCard.js';
+
+export class AiAgentManager {
+    constructor() {
+        this.list = document.getElementById('agentList');
+        this.agents = {};
+        this.cardRenderer = new AgentCardRenderer(
+            this.handleVariantCreate.bind(this),
+            this.handleAgentDelete.bind(this),
+            this.handleVariantDelete.bind(this)
+        );
+        
+        this.initializeEventListeners();
+        this.fetchAndRender();
+    }
+
+    initializeEventListeners() {
+        document.addEventListener('save-agent', async (e) => this.handleAgentSave(e.detail.agent));
+        document.addEventListener('select-agent', async (e) => this.handleAgentSelect(e.detail));
+    }
+
+    // Agent Selection Handlers
+    async handleAgentSelect({ type, agentId, variantId }) {
+        const agent = this.agents[agentId];
+        if (!agent) return;
+
+        const eventType = type === 'base' ? 'load-agent' : 'load-variant';
+        const eventDetail = type === 'base' 
+            ? { agent }
+            : { agent, variant: agent.variants?.[variantId] };
+
+        if (type === 'variant' && !agent.variants?.[variantId]) return;
+
+        document.dispatchEvent(new CustomEvent(eventType, { detail: eventDetail }));
+    }
+
+    // CRUD Operations
+    async handleAgentSave(agentData) {
+        try {
+            await AiAgentAPI.create(agentData);
+            await this.refreshAgents();
+            UIHelper.showToast('Agent saved successfully');
+        } catch (error) {
+            console.error('Failed to save agent:', error);
+            UIHelper.showAlert('Failed to save agent');
+        }
+    }
+
+    async handleAgentDelete(id) {
+        try {
+            await AiAgentAPI.delete(id);
+            await this.refreshAgents();
+            UIHelper.showToast('Agent deleted successfully');
+        } catch (error) {
+            console.error('Failed to delete agent:', error);
+            UIHelper.showAlert('Failed to delete agent');
+        }
+    }
+
+    async handleVariantCreate(agentId, variantName, variables) {
+        try {
+            await AiAgentAPI.addVariant(agentId, {
+                variant_name: variantName,
+                variables
+            });
+            await this.refreshAgents();
+            UIHelper.showToast('Variant created successfully');
+        } catch (error) {
+            console.error('Failed to save variant:', error);
+            UIHelper.showAlert('Failed to save variant');
+        }
+    }
+
+    async handleVariantDelete(agentId, variantId) {
+        try {
+            await AiAgentAPI.deleteVariant(agentId, variantId);
+            await this.refreshAgents();
+            UIHelper.showToast('Variant deleted successfully');
+        } catch (error) {
+            console.error('Failed to delete variant:', error);
+            UIHelper.showAlert('Failed to delete variant');
+        }
+    }
+
+    // Data Management
+    async fetchAndRender() {
+        try {
+            await this.refreshAgents();
+        } catch (error) {
+            console.error('Failed to fetch agents:', error);
+            UIHelper.showAlert('Failed to load agents');
+        }
+    }
+
+    async refreshAgents() {
+        this.agents = await AiAgentAPI.fetchAll();
+        this.render();
+        this.notifyAgentsUpdated();
+    }
+
+    notifyAgentsUpdated() {
+        document.dispatchEvent(new CustomEvent('agents-updated', {
+            detail: { 
+                agents: this.agents,
+                source: 'aiAgentManager'
+            }
+        }));
+    }
+
+    // Rendering
+    render() {
+        this.list.innerHTML = '';
+        Object.entries(this.agents).forEach(([id, data]) => {
+            const card = this.cardRenderer.createCard(id, data);
+            this.list.appendChild(card);
+        });
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/aiAgentManager.js b/src/static/js/components/aiAgentManager.js
new file mode 100644
index 0000000..4f2495f
--- /dev/null
+++ b/src/static/js/components/aiAgentManager.js
@@ -0,0 +1,65 @@
+import { AiAgentAPI } from '../api/aiAgents.js';
+
+export class AiAgentManager {
+    constructor() {
+        this.list = document.getElementById('agentList');
+        this.fetchAndRender()
+
+        // Listen for save events from PromptCards
+        document.addEventListener('save-agent', async (event) => {
+            await this.saveAgent(event.detail.agent);
+        });
+    }
+
+    async saveAgent(agentData) {
+        try {
+            await AiAgentAPI.create(agentData);
+            await this.fetchAndRender();
+        } catch (error) {
+            console.error('Failed to save agent:', error);
+            alert('Failed to save agent');
+        }
+    }
+
+    async fetchAndRender() {
+        const agents = await AiAgentAPI.fetchAll();
+        this.render(agents);
+
+        document.dispatchEvent(new CustomEvent('agents-updated', {
+            detail: { agents }
+        }));
+    }
+
+    render(agents) {
+        this.list.innerHTML = '';
+        for (const [id, data] of Object.entries(agents)) {
+            const card = this.createAgentCard(id, data);
+            this.list.appendChild(card);
+        }
+    }
+
+    createAgentCard(id, data) {
+        const card = document.createElement('div');
+        card.className = 'card';
+        card.innerHTML = `
+            <h3 class="card__title">${data.name}</h3>
+            <div class="card__content">
+                <h4>Prompt:</h4>
+                <pre class="card__prompt">${data.prompt[0].content}</pre>
+                <h4>Configuration:</h4>
+                <pre class="card__config">${JSON.stringify(data.config, null, 2)}</pre>
+            </div>
+            <button class="card__button--delete" data-id="${id}">
+                <i class="material-icons">delete</i> Delete
+            </button>
+        `;
+
+        card.querySelector('.card__button--delete').onclick = () => this.deleteAgent(id);
+        return card;
+    }
+
+    async deleteAgent(id) {
+        await AiAgentAPI.delete(id);
+        await this.fetchAndRender();
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/characterManager.js b/src/static/js/components/characterManager.js
deleted file mode 100644
index ad92836..0000000
--- a/src/static/js/components/characterManager.js
+++ /dev/null
@@ -1,69 +0,0 @@
-import { CharacterAPI } from '../api/characters.js';
-import { Panel } from './panel.js';
-
-export class CharacterManager {
-    constructor() {
-        this.list = document.getElementById('characterList');
-        this.addBtn = document.getElementById('addCharacterBtn');
-        this.panel = new Panel();
-        
-        this.addBtn.onclick = () => this.showAddPanel();
-        this.init();
-    }
-
-    async init() {
-        await this.fetchAndRender();
-    }
-
-    async fetchAndRender() {
-        const characters = await CharacterAPI.fetchAll();
-        this.render(characters);
-
-        document.dispatchEvent(new CustomEvent('characters-updated', {
-            detail: { characters }
-        }));
-    }
-
-    render(characters) {
-        this.list.innerHTML = '';
-        for (const [id, data] of Object.entries(characters)) {
-            const card = this.createCharacterCard(id, data);
-            this.list.appendChild(card);
-        }
-    }
-
-    createCharacterCard(id, data) {
-        const card = document.createElement('div');
-        card.className = 'card';
-        card.innerHTML = `
-            <h3 class="card__title">${data.name}</h3>
-            <p class="card__backstory">${data.backstory}</p>
-            <button class="button card__button--delete" data-id="${id}">
-                <i class="fas fa-trash"></i> Delete
-            </button>
-        `;
-
-        card.querySelector('.card__button--delete').onclick = () => this.deleteCharacter(id);
-        return card;
-    }
-
-    async deleteCharacter(id) {
-        await CharacterAPI.delete(id);
-        await this.fetchAndRender();
-    }
-
-    showAddPanel() {
-        this.panel.show('Add Character', [
-            {label: 'Name', type: 'text', name: 'name'},
-            {label: 'Backstory', type: 'textarea', name: 'backstory'},
-            {label: 'Model', type: 'select', name: 'model', 
-             options: ['gpt-4', 'claude-3-5-sonnet-20240620']},
-            {label: 'Temperature', type: 'range', name: 'temperature', 
-             min: 0, max: 1, step: 0.1},
-            {label: 'Max Tokens', type: 'number', name: 'max_tokens'}
-        ], async (data) => {
-            await CharacterAPI.create(data);
-            await this.fetchAndRender();
-        });
-    }
-}
\ No newline at end of file
diff --git a/src/static/js/components/dataset/datasetEditor.js b/src/static/js/components/dataset/datasetEditor.js
new file mode 100644
index 0000000..c9b9aa4
--- /dev/null
+++ b/src/static/js/components/dataset/datasetEditor.js
@@ -0,0 +1,381 @@
+import { DatasetAPI } from "../../api/datasets.js";
+import { AiAgentAPI } from "../../api/aiAgents.js";
+import { VariableHelper } from "../../utils/variableHelper.js";
+import { UIHelper } from "../../utils/uiHelper.js";
+
+export class DatasetEditor {
+    constructor() {
+        this.container = document.getElementById('datasetEditor');
+        this.sampleCount = 1;
+        this.currentAgent = null;
+        this.freeVariables = new Set();
+        this.agents = new Map();
+        this.sampleTemplate = null;
+        this.init();
+    }
+
+    get isNewDataset() {
+        return window.location.hash === '#dataset/new';
+    }
+
+    async init() {
+        this.render();
+        this.attachEventListeners();
+        if (this.isNewDataset) {
+            const agents = await AiAgentAPI.fetchAll();
+            this.handleAgentsUpdate(agents);
+        }
+    }
+
+    render() {
+        this.container.innerHTML = `
+            <div class="editor-header">
+                <h2>${this.isNewDataset ? 'Create' : 'Edit'} Dataset</h2>
+                <button class="button button--secondary" id="backToList">Back to List</button>
+            </div>
+            <div class="editor-content">
+                <div class="editor-row">
+                    <div class="dataset-name">
+                        <label class="form__label">Dataset Name</label>
+                        <input type="text" id="datasetName" class="form__input" required>
+                    </div>
+                    ${this.isNewDataset ? `
+                        <div class="agent-select">
+                            <label class="form__label">Select Agent</label>
+                            <select id="agentSelect" class="form__input">
+                                <option value="">Select an agent...</option>
+                            </select>
+                        </div>
+                    ` : ''}
+                </div>
+
+                <div class="samples-container">
+                    <div class="sample-controls">
+                        <input type="number" id="sampleCount" placeholder="No. of samples" min="1">
+                        <button class="button button--primary" id="generateSamples">Generate Samples</button>
+                        <button class="button button--secondary" id="addSample">Add Sample</button>
+                    </div>
+                    <div id="samplesList">
+                        ${this.createSampleCard(1)}
+                    </div>
+                    <div class="editor-actions">
+                        <button class="button button--primary" id="saveDataset">Save Dataset</button>
+                    </div>
+                </div>
+            </div>
+        `;
+    }
+
+    createSampleCard(index, sample = null) {
+        const isFirstCard = index === 1;
+        return `
+            <div class="sample-card">
+                <div class="sample-header" data-sample="${index}">
+                    <span>Sample #${index}</span>
+                    <i class="material-icons">${isFirstCard ? 'expand_less' : 'expand_more'}</i>
+                </div>
+                <div class="sample-content" style="display: ${isFirstCard ? 'block' : 'none'}">
+                    ${this.createSampleContent(sample)}
+                </div>
+            </div>
+        `;
+    }
+
+    createSampleContent(sample) {
+        if (!sample) {
+            if (this.isNewDataset && !this.currentAgent) {
+                return '<p class="no-agent-message">Please select an agent first</p>';
+            }
+            if (!this.isNewDataset && !this.sampleTemplate) {
+                return '<p class="no-template-message">Loading...</p>';
+            }
+            sample = this.createEmptySample();
+        }
+        return this.createSampleInputs(sample);
+    }
+
+    createEmptySample() {
+        if (this.isNewDataset) {
+            return {};
+        }
+        // Create empty sample based on template
+        const sample = {};
+        if (this.sampleTemplate.free_variables) {
+            sample.free_variables = {};
+            Object.keys(this.sampleTemplate.free_variables).forEach(key => {
+                sample.free_variables[key] = '';
+            });
+        } else if (this.sampleTemplate.user_prompt !== undefined) {
+            sample.user_prompt = '';
+        }
+        return sample;
+    }
+
+    createSampleInputs(sample = {}) {
+        return `
+            <div class="sample-inputs">
+                ${this.isNewDataset ? 
+                    (this.freeVariables.size > 0 ? 
+                        this.createVariableInputs({ free_variables: Object.fromEntries([...this.freeVariables].map(v => [v, ''])) }) : 
+                        this.createUserPromptInput('')) : 
+                    (sample.free_variables ? 
+                        this.createVariableInputs(sample) : 
+                        this.createUserPromptInput(sample.user_prompt))
+                }
+                ${this.createOptionalInputs(sample)}
+            </div>
+        `;
+    }
+
+    createUserPromptInput(prompt = '') {
+        return `
+            <div class="form-group">
+                <label class="form__label">User Prompt</label>
+                <textarea class="form__input user-prompt" rows="3">${prompt}</textarea>
+            </div>
+        `;
+    }
+
+    createVariableInputs(sample) {
+        const variables = sample.free_variables ? 
+            Object.entries(sample.free_variables) : 
+            [];
+
+        return `
+            <div class="variables">
+                ${variables.map(([key, value = '']) => `
+                    <div class="form-group">
+                        <label class="form__label">${key}</label>
+                        <input type="text" 
+                               name="${key}" 
+                               class="form__input" 
+                               value="${value}">
+                    </div>
+                `).join('')}
+            </div>
+        `;
+    }
+
+    createOptionalInputs(sample = {}) {
+        return `
+            <div class="form-group">
+                <label class="form__label">Evaluation Schema (Optional)</label>
+                <textarea class="form__input eval-schema" rows="2" 
+                          placeholder="Enter evaluation guidelines...">${sample.evaluation_schema || ''}</textarea>
+            </div>
+            <div class="form-group">
+                <label class="form__label">Expected Output (Optional)</label>
+                <textarea class="form__input expected-output" rows="3"
+                          placeholder="Enter expected output...">${sample.expected_output || ''}</textarea>
+            </div>
+        `;
+    }
+
+    attachEventListeners() {
+        document.getElementById('backToList').onclick = () => this.handleBackToList();
+        document.getElementById('addSample').onclick = () => this.handleAddSample();
+        document.getElementById('generateSamples').onclick = () => this.handleGenerateSamples();
+        document.getElementById('saveDataset').onclick = () => this.handleSaveDataset();
+        
+        if (this.isNewDataset) {
+            document.getElementById('agentSelect').onchange = (e) => this.handleAgentSelection(e.target.value);
+        }
+
+        this.attachSampleHeaderListeners();
+        this.attachCustomEventListeners();
+    }
+
+    attachSampleHeaderListeners() {
+        document.getElementById('samplesList').addEventListener('click', (e) => {
+            const header = e.target.closest('.sample-header');
+            if (header) {
+                this.toggleSampleContent(header);
+            }
+        });
+    }
+
+    attachCustomEventListeners() {
+        document.addEventListener('dataset-load', (event) => this.handleDatasetLoad(event.detail.dataset));
+        document.addEventListener('agents-updated', (event) => this.handleAgentsUpdate(event.detail.agents));
+    }
+
+    handleBackToList() {
+        window.location.hash = '#datasets';
+    }
+
+    handleAddSample() {
+        this.sampleCount++;
+        const samplesList = document.getElementById('samplesList');
+        samplesList.insertAdjacentHTML('beforeend', this.createSampleCard(this.sampleCount));
+    }
+
+    handleGenerateSamples() {
+        UIHelper.showToast('To be implemented', 'info');
+    }
+
+    toggleSampleContent(header) {
+        const content = header.nextElementSibling;
+        content.style.display = content.style.display === 'none' ? 'block' : 'none';
+        const icon = header.querySelector('.material-icons');
+        icon.textContent = content.style.display === 'none' ? 'expand_more' : 'expand_less';
+    }
+
+    handleDatasetLoad(dataset) {
+        document.getElementById('datasetName').value = dataset.name;
+        this.sampleTemplate = dataset.samples[0];
+        this.regenerateSamplesList(dataset.samples);
+    }
+
+    regenerateSamplesList(samples) {
+        const samplesList = document.getElementById('samplesList');
+        samplesList.innerHTML = '';
+        this.sampleCount = samples.length;
+        
+        samples.forEach((sample, index) => {
+            samplesList.insertAdjacentHTML('beforeend', 
+                this.createSampleCard(index + 1, sample)
+            );
+        });
+    }
+
+    handleAgentsUpdate(agents) {
+        this.agents = new Map(Object.entries(agents));
+        this.updateAgentDropdown();
+    }
+
+    handleAgentSelection(agentId) {
+        if (!agentId) {
+            this.currentAgent = null;
+            this.freeVariables.clear();
+            this.updateSampleInputs();
+            return;
+        }
+
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            this.currentAgent = agent;
+            this.updateFreeVariables(agent);
+            this.updateSampleInputs();
+        }
+    }
+
+    updateFreeVariables(agent) {
+        const allVariables = new Set();
+        agent.prompt.forEach(prompt => {
+            const promptVariables = VariableHelper.extractVariables(prompt.content);
+            promptVariables.forEach(variable => allVariables.add(variable));
+        });
+
+        this.freeVariables = new Set(
+            [...allVariables].filter(variable => 
+                !agent.included_variables?.includes(variable)
+            )
+        );
+    }
+
+    updateAgentDropdown() {
+        const agentSelect = document.getElementById('agentSelect');
+        agentSelect.innerHTML = '<option value="">Select an agent...</option>';
+        
+        this.agents.forEach((agent, id) => {
+            const option = document.createElement('option');
+            option.value = id;
+            option.textContent = agent.name;
+            agentSelect.appendChild(option);
+        });
+    }
+
+    updateSampleInputs() {
+        const samplesList = document.getElementById('samplesList');
+        const samples = samplesList.querySelectorAll('.sample-card');
+        
+        samples.forEach(sample => {
+            sample.querySelector('.sample-content').innerHTML = this.createSampleInputs({});
+        });
+    }
+
+    async handleSaveDataset() {
+        const name = document.getElementById('datasetName').value;
+        if (!name) {
+            alert('Please enter a dataset name');
+            return;
+        }
+
+        const samples = this.collectSamples();
+        if (samples.length === 0) {
+            alert('Please add at least one sample');
+            return;
+        }
+
+        try {
+            await this.saveDatasetToServer(name, samples);
+            window.location.hash = '#datasets';
+        } catch (error) {
+            console.error('Error saving dataset:', error);
+            alert('Failed to save dataset');
+        }
+    }
+
+    collectSamples() {
+        const samples = [];
+        const sampleCards = document.querySelectorAll('.sample-card');
+        
+        for (const card of sampleCards) {
+            const sample = this.collectSampleData(card);
+            if (Object.keys(sample).length > 0) {
+                samples.push(sample);
+            }
+        }
+        return samples;
+    }
+
+    collectSampleData(card) {
+        const sample = {};
+        
+        // Get user prompt or variables
+        const userPrompt = card.querySelector('.user-prompt');
+        if (userPrompt && userPrompt.value) {
+            sample.user_prompt = userPrompt.value;
+        } else {
+            const variables = card.querySelectorAll('.variables input');
+            if (variables.length > 0) {
+                sample.free_variables = {};
+                variables.forEach(input => {
+                    if (input.value) {
+                        sample.free_variables[input.name] = input.value;
+                    }
+                });
+            }
+        }
+
+        // Get optional fields
+        this.collectOptionalFields(card, sample);
+        return sample;
+    }
+
+    collectOptionalFields(card, sample) {
+        const evalSchema = card.querySelector('.eval-schema');
+        if (evalSchema && evalSchema.value) {
+            sample.evaluation_schema = evalSchema.value;
+        }
+
+        const expectedOutput = card.querySelector('.expected-output');
+        if (expectedOutput && expectedOutput.value) {
+            sample.expected_output = expectedOutput.value;
+        }
+    }
+
+    async saveDatasetToServer(name, samples) {
+        const datasetData = { name, samples };
+        const hash = window.location.hash;
+        
+        if (hash.startsWith('#dataset/') && hash !== '#dataset/new') {
+            const datasetId = hash.split('/')[1];
+            await DatasetAPI.update(datasetId, datasetData);
+            UIHelper.showToast('Dataset updated successfully');
+        } else {
+            await DatasetAPI.create(datasetData);
+            UIHelper.showToast('Dataset created successfully');
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/dataset/datasetManager.js b/src/static/js/components/dataset/datasetManager.js
new file mode 100644
index 0000000..33d3701
--- /dev/null
+++ b/src/static/js/components/dataset/datasetManager.js
@@ -0,0 +1,171 @@
+import { DatasetAPI } from '../../api/datasets.js';
+import { DatasetEditor } from './datasetEditor.js';
+
+export class DatasetManager {
+    constructor() {
+        this.list = document.getElementById('datasetList');
+        this.addBtn = document.getElementById('addDatasetBtn');
+        this.listView = document.getElementById('datasetsListView');
+        this.editorView = document.getElementById('datasetEditor');
+        
+        // Update add button click handler
+        this.addBtn.onclick = () => this.showEditor();
+
+        // Handle hash changes for navigation
+        window.addEventListener('hashchange', () => this.handleNavigation());
+        this.handleNavigation();
+
+        document.querySelector('a[href="#datasets"]').addEventListener('click', () => {
+            window.location.hash = '#datasets';
+        });
+    }
+
+    handleNavigation() {
+        const hash = window.location.hash || '#datasets';
+
+        if (hash === '#datasets') {
+            this.listView.style.display = 'block';
+            this.editorView.style.display = 'none';
+            this.fetchAndRender();
+        } else if (hash.startsWith('#dataset/')) {
+            this.listView.style.display = 'none';
+            this.editorView.style.display = 'block';
+            
+            // Re-initialize editor for each navigation
+            this.editor = new DatasetEditor();
+            
+            const id = hash.split('/')[1];
+            if (id !== 'new') {
+                // Load existing dataset
+                this.loadDataset(id);
+            }
+        }
+    }
+
+    showEditor(datasetId = null) {
+        window.location.hash = datasetId ? `#dataset/${datasetId}` : '#dataset/new';
+    }
+
+    async init() {
+        await this.fetchAndRender();
+    }
+
+    async fetchAndRender() {
+        if (this.listView.style.display === 'none') {
+            return;
+        }
+
+        const datasets = await DatasetAPI.fetchAll();
+        if (!this.currentDatasets || JSON.stringify(datasets) !== JSON.stringify(this.currentDatasets)) {
+            this.currentDatasets = datasets;
+            this.render(datasets);
+        }
+
+        document.dispatchEvent(new CustomEvent('datasets-updated', {
+            detail: { datasets }
+        }));
+    }
+
+    render(datasets) {
+        this.list.innerHTML = '';
+        for (const [id, data] of Object.entries(datasets)) {
+            const card = this.createDatasetCard(id, data);
+            this.list.appendChild(card);
+        }
+    }
+
+    createDatasetCard(id, data) {
+        const card = document.createElement('div');
+        card.className = 'card';
+        card.innerHTML = `
+            <div class="card__info">
+                <h3 class="card__title">${data.name}</h3>
+                <p class="card__samples">Samples: ${data.samples.length}</p>
+            </div>
+            <div class="card__actions">
+                <button class="button button--secondary card__button--edit" data-id="${id}">
+                    <i class="material-icons">edit</i> Edit
+                </button>
+                <button class="button button--danger card__button--delete" data-id="${id}">
+                    <i class="material-icons">delete</i> Delete
+                </button>
+            </div>
+        `;
+    
+        // Add click handlers
+        card.querySelector('.card__button--edit').onclick = () => this.showEditor(id);
+        card.querySelector('.card__button--delete').onclick = () => this.deleteDataset(id);
+        
+        return card;
+    }
+
+    async loadDataset(id) {
+        try {
+            const dataset = await DatasetAPI.fetchById(id);
+            if (dataset) {
+                // Dispatch event to load the dataset into editor
+                document.dispatchEvent(new CustomEvent('dataset-load', {
+                    detail: { dataset }
+                }));
+            } else {
+                alert('Dataset not found');
+                window.location.hash = '#datasets';
+            }
+        } catch (error) {
+            console.error('Error loading dataset:', error);
+            alert('Failed to load dataset');
+            window.location.hash = '#datasets';
+        }
+    }
+
+    async deleteDataset(id) {
+        if (confirm('Are you sure you want to delete this dataset?')) {
+            try {
+                await DatasetAPI.delete(id);
+                await this.fetchAndRender();
+            } catch (error) {
+                console.error('Error deleting dataset:', error);
+                alert('Failed to delete dataset');
+            }
+        }
+    }
+
+    showQuestionsPreview(data, questions) {
+        // Clear previous questions and save button if they exist
+        const form = this.panel.form;
+
+        const existingQuestions = form.querySelector('#generatedQuestions');
+        const existingSaveBtn = form.querySelector('#saveDatasetBtn');
+        if (existingQuestions) existingQuestions.remove();
+        if (existingSaveBtn) existingSaveBtn.remove();
+
+        // Create questions preview
+        const questionsDiv = document.createElement('div');
+        questionsDiv.id = 'generatedQuestions';
+        questionsDiv.className = 'form__questions';
+        questionsDiv.innerHTML = `
+            <h4>Generated Questions:</h4>
+            <ul>${questions.map(q => `<li>${q}</li>`).join('')}</ul>
+        `;
+
+        // Create save button
+        const saveBtn = document.createElement('button');
+        saveBtn.id = 'saveDatasetBtn';
+        saveBtn.className = 'button button--primary panel__save-btn';
+        saveBtn.textContent = 'Save Dataset';
+        saveBtn.onclick = async (e) => {
+            e.preventDefault();
+            data.questions = questions;
+            await DatasetAPI.create(data);
+            await this.fetchAndRender();
+            this.panel.close();
+        };
+
+        // Append both elements
+        form.appendChild(questionsDiv);
+        form.appendChild(saveBtn);
+
+        // Scroll to show new content
+        this.panel.panel.scrollTop = this.panel.panel.scrollHeight;
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/datasetEditor.js b/src/static/js/components/datasetEditor.js
new file mode 100644
index 0000000..907b84f
--- /dev/null
+++ b/src/static/js/components/datasetEditor.js
@@ -0,0 +1,268 @@
+import { DatasetAPI } from "../api/datasets.js";
+
+export class DatasetEditor {
+    constructor() {
+        this.container = document.getElementById('datasetEditor');
+        this.testcaseCount = 1;
+        this.currentAgent = null;
+        this.promptVariables = new Set();
+        this.agents = new Map();
+        this.init();
+    }
+
+    init() {
+        this.render();
+        this.attachEventListeners();
+    }
+
+    render() {
+        this.container.innerHTML = `
+            <div class="editor-header">
+                <h2>Create Dataset</h2>
+                <button class="button button--secondary" id="backToList">Back to List</button>
+            </div>
+            <div class="editor-content">
+                <div class="editor-row">
+                    <div class="dataset-type">
+                        <label class="form__label">Dataset Type</label>
+                        <select id="datasetType" class="form__input">
+                            <option value="objective">Objective Dataset</option>
+                            <option value="subjective">Subjective Dataset</option>
+                        </select>
+                    </div>
+                    <div class="agent-select">
+                        <label class="form__label">Select Agent</label>
+                        <select id="agentSelect" class="form__input">
+                            <option value="">Select an agent...</option>
+                        </select>
+                    </div>
+                </div>
+
+                <div class="testcases-container">
+                    <div class="testcase-controls">
+                        <input type="number" id="testcaseCount" placeholder="No. of testcases" min="1">
+                        <button class="button button--primary" id="generateTestcases">Generate Testcases</button>
+                        <button class="button button--secondary" id="addTestcase" disabled>Add Testcase</button>
+                    </div>
+                    <div id="testcasesList">
+                        ${this.createTestcaseCard(1)}
+                    </div>
+                </div>
+            </div>
+        `;
+    }
+
+    createTestcaseCard(index) {
+        return `
+            <div class="testcase-card">
+                <div class="testcase-header" data-testcase="${index}">
+                    <span>Testcase #${index}</span>
+                    <i class="material-icons">expand_more</i>
+                </div>
+                <div class="testcase-content">
+                    <div class="input-variables">
+                        ${this.currentAgent ? 
+                            Array.from(this.promptVariables).map(variable => `
+                                <div class="form-group">
+                                    <label class="form__label">${variable}</label>
+                                    <input type="text" 
+                                           name="${variable}" 
+                                           class="form__input" 
+                                           placeholder="Enter ${variable}">
+                                </div>
+                            `).join('') : 
+                            '<p class="no-agent-message">Please select an agent first</p>'
+                        }
+                    </div>
+                    <div class="questions-section">
+                        <h4>Questions</h4>
+                        <div class="form-group">
+                            <label class="form__label">Number of Questions</label>
+                            <input type="number" 
+                                   class="form__input question-count" 
+                                   min="1" 
+                                   value="3">
+                        </div>
+                        <div class="form-group">
+                            <label class="form__label">Generation Guidelines</label>
+                            <textarea class="form__input generation-guidelines" 
+                                     placeholder="Enter guidelines for question generation..."
+                                     rows="2"></textarea>
+                        </div>
+                        <textarea class="questions-area form__input" rows="4"></textarea>
+                        <div class="testcase-actions">
+                            <button class="button button--secondary generate-questions">Generate Questions</button>
+                            ${index > 1 ? '<button class="button button--danger remove-testcase">Remove Testcase</button>' : ''}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        `;
+    }
+
+    attachEventListeners() {
+        document.addEventListener('agents-updated', (event) => {
+            this.agents.clear();
+            Object.entries(event.detail.agents).forEach(([id, agent]) => {
+                this.agents.set(id, agent);
+            });
+            this.updateAgentDropdown();
+        });
+
+        const backBtn = document.getElementById('backToList');
+        backBtn.onclick = () => {
+            window.location.hash = '#datasets';
+        };
+
+        const agentSelect = document.getElementById('agentSelect');
+        agentSelect.addEventListener('change', (e) => this.handleAgentSelection(e.target.value));
+
+        const addTestcaseBtn = document.getElementById('addTestcase');
+        addTestcaseBtn.onclick = () => {
+            this.testcaseCount++;
+            const testcasesList = document.getElementById('testcasesList');
+            testcasesList.insertAdjacentHTML('beforeend', this.createTestcaseCard(this.testcaseCount));
+        };
+
+        // Toggle testcase content
+        this.container.addEventListener('click', (e) => {
+            const header = e.target.closest('.testcase-header');
+            if (header) {
+                const content = header.nextElementSibling;
+                content.style.display = content.style.display === 'none' ? 'block' : 'none';
+                const icon = header.querySelector('.material-icons');
+                icon.textContent = content.style.display === 'none' ? 'expand_more' : 'expand_less';
+            }
+
+            // Handle remove testcase
+            if (e.target.classList.contains('remove-testcase')) {
+                const card = e.target.closest('.testcase-card');
+                card.remove();
+                this.testcaseCount--;
+            }
+        });
+
+        // Handle generate testcases
+        const generateTestcasesBtn = document.getElementById('generateTestcases');
+        generateTestcasesBtn.onclick = () => {
+            const count = parseInt(document.getElementById('testcaseCount').value);
+            if (count && count > 0) {
+                const testcasesList = document.getElementById('testcasesList');
+                testcasesList.innerHTML = '';
+                this.testcaseCount = count;
+                
+                for (let i = 1; i <= count; i++) {
+                    testcasesList.insertAdjacentHTML('beforeend', this.createTestcaseCard(i));
+                }
+            }
+        };
+
+        this.container.addEventListener('click', async (e) => {
+            if (e.target.classList.contains('generate-questions')) {
+                const card = e.target.closest('.testcase-card');
+                await this.handleGenerateQuestions(card);
+            }
+        });
+    }
+    
+    async handleGenerateQuestions(card) {
+        const questionsArea = card.querySelector('.questions-area');
+        if (questionsArea.value.trim()) {
+            alert('Questions area must be empty to generate new questions');
+            return;
+        }
+    
+        // Get all input values
+        const inputValues = {};
+        const inputs = card.querySelectorAll('.input-variables input');
+        let allFilled = true;
+        
+        inputs.forEach(input => {
+            if (!input.value.trim()) {
+                allFilled = false;
+            }
+            inputValues[input.name] = input.value.trim();
+        });
+    
+        if (!allFilled) {
+            alert('Please fill all input variables before generating questions');
+            return;
+        }
+    
+        const numQuestions = card.querySelector('.question-count').value;
+        const guidelines = card.querySelector('.generation-guidelines').value.trim();
+        const datasetType = document.getElementById('datasetType').value;
+    
+        try {
+            const response = await DatasetAPI.generateQuestions({
+                agent: {
+                    prompt: this.currentAgent.prompt[0].content,
+                    config: this.currentAgent.config
+                },
+                datasetType,
+                numQuestions,
+                guidelines,
+                inputs: inputValues
+            });
+    
+            questionsArea.value = response.join('\n');
+        } catch (error) {
+            console.error('Error generating questions:', error);
+            alert('Failed to generate questions. Please try again.');
+        }
+    }
+
+    handleAgentSelection(agentId) {
+        if (!agentId) {
+            this.currentAgent = null;
+            this.promptVariables.clear();
+            this.updateTestcaseInputs();
+            document.getElementById('addTestcase').disabled = true;
+            return;
+        }
+
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            this.currentAgent = agent;
+            this.promptVariables = this.extractVariables(agent.prompt[0].content);
+            this.updateTestcaseInputs();
+            document.getElementById('addTestcase').disabled = false;
+        }
+    }
+
+    extractVariables(promptTemplate) {
+        const regex = /{([^}]+)}/g;
+        const matches = [...promptTemplate.matchAll(regex)];
+        return new Set(matches.map(match => match[1]));
+    }
+
+    updateTestcaseInputs() {
+        const inputContainers = document.querySelectorAll('.input-variables');
+        inputContainers.forEach(container => {
+            container.innerHTML = this.currentAgent ? 
+                Array.from(this.promptVariables).map(variable => `
+                    <div class="form-group">
+                        <label class="form__label">${variable}</label>
+                        <input type="text" 
+                               name="${variable}" 
+                               class="form__input" 
+                               placeholder="Enter ${variable}">
+                    </div>
+                `).join('') : 
+                '<p class="no-agent-message">Please select an agent first</p>';
+        });
+    }
+
+    updateAgentDropdown() {
+        const agentSelect = document.getElementById('agentSelect');
+        if (agentSelect) {
+            agentSelect.innerHTML = '<option value="">Select an agent...</option>';
+            this.agents.forEach((agent, id) => {
+                const option = document.createElement('option');
+                option.value = id;
+                option.textContent = agent.name;
+                agentSelect.appendChild(option);
+            });
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/datasetManager.js b/src/static/js/components/datasetManager.js
deleted file mode 100644
index 8fb2463..0000000
--- a/src/static/js/components/datasetManager.js
+++ /dev/null
@@ -1,114 +0,0 @@
-import { DatasetAPI } from '../api/datasets.js';
-import { CharacterAPI } from '../api/characters.js';
-import { Panel } from './panel.js';
-
-export class DatasetManager {
-    constructor() {
-        this.list = document.getElementById('datasetList');
-        this.addBtn = document.getElementById('addDatasetBtn');
-        this.panel = new Panel();
-        
-        this.addBtn.onclick = () => this.showAddPanel();
-        this.init();
-    }
-
-    async init() {
-        await this.fetchAndRender();
-    }
-
-    async fetchAndRender() {
-        const datasets = await DatasetAPI.fetchAll();
-        this.render(datasets);
-
-        document.dispatchEvent(new CustomEvent('datasets-updated', {
-            detail: { datasets }
-        }));
-    }
-
-    render(datasets) {
-        this.list.innerHTML = '';
-        for (const [id, data] of Object.entries(datasets)) {
-            const card = this.createDatasetCard(id, data);
-            this.list.appendChild(card);
-        }
-    }
-
-    createDatasetCard(id, data) {
-        const card = document.createElement('div');
-        card.className = 'card';
-        card.innerHTML = `
-            <h3 class="card__title">${data.name}</h3>
-            <p class="card__metric">Metric: ${data.metric_name}</p>
-            <p class="card__questions">Questions: ${data.questions.length}</p>
-            <button class="button card__button--delete" data-id="${id}">
-                <i class="fas fa-trash"></i> Delete
-            </button>
-        `;
-
-        card.querySelector('.card__button--delete').onclick = () => this.deleteDataset(id);
-        return card;
-    }
-
-    async deleteDataset(id) {
-        await DatasetAPI.delete(id);
-        await this.fetchAndRender();
-    }
-
-    async showAddPanel() {
-        const characters = await CharacterAPI.fetchAll();
-        const characterOptions = Object.entries(characters).map(([id, data]) => ({
-            value: id,
-            label: data.name
-        }));
-
-        this.panel.show('Add Dataset', [
-            {label: 'Name', type: 'text', name: 'name'},
-            {label: 'Metric Name', type: 'text', name: 'metric_name'},
-            {label: 'Metric Description', type: 'textarea', name: 'metric_description'},
-            {label: 'Number of Questions', type: 'number', name: 'num_questions'},
-            {label: 'Character', type: 'select', name: 'character', options: characterOptions}
-        ], async (data) => {
-            const questions = await DatasetAPI.generateQuestions(data);
-            this.showQuestionsPreview(data, questions);
-        }, false);
-    }
-
-    showQuestionsPreview(data, questions) {
-        // Clear previous questions and save button if they exist
-        const form = this.panel.form;
-
-        const existingQuestions = form.querySelector('#generatedQuestions');
-        const existingSaveBtn = form.querySelector('#saveDatasetBtn');
-        if (existingQuestions) existingQuestions.remove();
-        if (existingSaveBtn) existingSaveBtn.remove();
-
-        // Create questions preview
-        const questionsDiv = document.createElement('div');
-        questionsDiv.id = 'generatedQuestions';
-        questionsDiv.className = 'form__questions';
-        questionsDiv.innerHTML = `
-            <h4>Generated Questions:</h4>
-            <ul>${questions.map(q => `<li>${q}</li>`).join('')}</ul>
-        `;
-
-        // Create save button
-        const saveBtn = document.createElement('button');
-        saveBtn.id = 'saveDatasetBtn';
-        saveBtn.className = 'button button--primary panel__save-btn';
-        saveBtn.textContent = 'Save Dataset';
-        saveBtn.onclick = async (e) => {
-            e.preventDefault();
-            data.questions = questions;
-            await DatasetAPI.create(data);
-            await this.fetchAndRender();
-            this.panel.close();
-        };
-
-        // Append both elements
-        form.appendChild(questionsDiv);
-        form.appendChild(saveBtn);
-
-        // Scroll to show new content
-        this.panel.panel.scrollTop = this.panel.panel.scrollHeight;
-    }
-}
\ No newline at end of file
diff --git a/src/static/js/components/evaluation/evaluationManager.js b/src/static/js/components/evaluation/evaluationManager.js
new file mode 100644
index 0000000..8d5c40a
--- /dev/null
+++ b/src/static/js/components/evaluation/evaluationManager.js
@@ -0,0 +1,71 @@
+import { UIHelper } from '../../utils/uiHelper.js';
+
+export class EvaluationManager {
+    constructor() {
+        this.initializeElements();
+        this.initializeEventListeners();
+    }
+
+    initializeElements() {
+        this.datasetSelect = document.getElementById('evalDatasetSelect');
+        this.evaluateBtn = document.getElementById('evaluateBtn');
+        this.results = document.getElementById('evaluationResults');
+        this.dynamicInputs = document.querySelector('.dynamic-inputs');
+    }
+
+    initializeEventListeners() {
+        this.evaluateBtn.onclick = () => this.evaluate();
+    }
+
+    evaluate() {
+        const prompts = Array.from(document.querySelectorAll('.prompt-template'))
+            .map(template => template.value);
+        const datasetId = this.datasetSelect.value;
+        
+        if (!this.validateEvaluation(prompts, datasetId)) {
+            return;
+        }
+
+        const inputs = this.collectVariables();
+        this.displayResults(prompts, inputs, datasetId);
+    }
+
+    validateEvaluation(prompts, datasetId) {
+        if (prompts.some(p => !p) || !datasetId) {
+            UIHelper.showAlert('Please provide all prompt templates and select a dataset.');
+            return false;
+        }
+        return true;
+    }
+
+    collectVariables() {
+        const inputs = {};
+        this.dynamicInputs.querySelectorAll('input').forEach(input => {
+            inputs[input.dataset.variable] = input.value;
+        });
+        return inputs;
+    }
+
+    displayResults(prompts, inputs, datasetId) {
+        this.results.innerHTML = `
+            <div class="evaluation-result">
+                <h3>Prompts:</h3>
+                ${prompts.map((p, i) => `
+                    <pre>Prompt ${i + 1}: ${p}</pre>
+                `).join('')}
+                <h3>Shared Variables:</h3>
+                <pre>${JSON.stringify(inputs, null, 2)}</pre>
+                <h3>Selected Dataset:</h3>
+                <pre>${datasetId}</pre>
+            </div>
+        `;
+    }
+
+    clear() {
+        if (this.dynamicInputs) {
+            this.dynamicInputs.innerHTML = '';
+        }
+        this.results.innerHTML = '';
+        this.datasetSelect.value = '';
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/evaluationManager.js b/src/static/js/components/evaluationManager.js
index 0ee9f71..e69de29 100644
--- a/src/static/js/components/evaluationManager.js
+++ b/src/static/js/components/evaluationManager.js
@@ -1,80 +0,0 @@
-import { EvaluationAPI } from '../api/evaluation.js';
-import { FormHelper } from '../utils/formHelper.js';
-
-export class EvaluationManager {
-    constructor() {
-        this.characterSelect = document.getElementById('evalCharacterSelect');
-        this.datasetSelect = document.getElementById('evalDatasetSelect');
-        this.evaluateBtn = document.getElementById('evaluateBtn');
-        this.clearBtn = document.getElementById('clearEvaluationBtn');
-        this.results = document.getElementById('evaluationResults');
-
-        this.evaluateBtn.onclick = () => this.evaluate();
-        this.clearBtn.onclick = () => this.clear();
-
-        document.addEventListener('characters-updated', (event) => {
-            this.populateDropdown(this.characterSelect, event.detail.characters, "Select a character");
-        });
-
-        document.addEventListener('datasets-updated', (event) => {
-            this.populateDropdown(this.datasetSelect, event.detail.datasets, "Select a dataset");
-        });
-    }
-
-    populateDropdown(selectElement, data, defaultText = "Select an option") {
-        FormHelper.populateDropdown(selectElement, data, defaultText);
-    }
-
-    async evaluate() {
-        const characterId = this.characterSelect.value;
-        const datasetId = this.datasetSelect.value;
-
-        if (!characterId || !datasetId) {
-            alert('Please select both a character and a dataset.');
-            return;
-        }
-
-        this.showLoading();
-        try {
-            const data = await EvaluationAPI.evaluate(characterId, datasetId);
-            this.renderResults(data);
-        } catch (error) {
-            this.showError(error);
-        }
-    }
-
-    showLoading() {
-        this.evaluateBtn.disabled = true;
-        this.results.innerHTML = '<div class="loading-indicator">Evaluation in progress... Please wait.</div>';
-    }
-
-    renderResults(data) {
-        this.results.innerHTML = '';
-        
-        const totalScore = document.createElement('h3');
-        totalScore.textContent = `Total Score: ${data.total_score}/${data.max_score}`;
-        this.results.appendChild(totalScore);
-
-        data.results.forEach(result => {
-            const resultDiv = document.createElement('div');
-            resultDiv.className = 'evaluation-result';
-            resultDiv.innerHTML = `
-                <p><strong>Question:</strong> ${result.question}</p>
-                <p><strong>Response:</strong> ${result.response}</p>
-                <p><strong>Score:</strong> ${result.score}</p>
-            `;
-            this.results.appendChild(resultDiv);
-        });
-
-        this.evaluateBtn.disabled = false;
-    }
-
-    showError(error) {
-        this.results.innerHTML = `<div class="error">An error occurred: ${error.message}</div>`;
-        this.evaluateBtn.disabled = false;
-    }
-
-    clear() {
-        this.results.innerHTML = '';
-    }
-}
\ No newline at end of file
diff --git a/src/static/js/components/header.js b/src/static/js/components/header.js
deleted file mode 100644
index 8e79a0b..0000000
--- a/src/static/js/components/header.js
+++ /dev/null
@@ -1,25 +0,0 @@
-import { logout } from "../api/auth.js";
-import { getCurrentSession } from "../api/session.js";
-
-export async function initializeHeader() {
-    // Fetch user session info
-    const response = await getCurrentSession();
-    if (response.ok) {
-        const data = await response.json();
-        const user = data.user;
-        document.getElementById('userName').textContent = `Hello, ${user.name}`;
-    } else {
-        // Redirect to login if session is not valid
-        window.location.href = '/login';
-    }
-
-    // Logout functionality
-    document.getElementById('logoutButton').addEventListener('click', async () => {
-        const response = await logout();
-        if (response.ok) {
-            window.location.href = '/login';
-        } else {
-            console.error('Logout failed');
-        }
-    });
-}
\ No newline at end of file
diff --git a/src/static/js/components/navigation/navigation.js b/src/static/js/components/navigation/navigation.js
new file mode 100644
index 0000000..a350c5f
--- /dev/null
+++ b/src/static/js/components/navigation/navigation.js
@@ -0,0 +1,158 @@
+import { logout } from "../../api/auth.js";
+import { getCurrentSession } from "../../api/session.js";
+import { UIHelper } from "../../utils/uiHelper.js";
+
+export class Navigation {
+    constructor() {
+        this.tabItems = document.querySelectorAll('.sidenav__item');
+        this.tabContents = document.querySelectorAll('.tab-content');
+        this.userNameElement = document.getElementById('userName');
+        this.userAvatarElement = document.getElementById('userAvatar');
+        this.signOutBtn = document.getElementById('signOutBtn');
+        this.menuToggle = document.getElementById('menuToggle');
+        this.sidenav = document.querySelector('.sidenav');
+        
+        // Map tabs to content IDs
+        this.tabMapping = {
+            'playground': 'evaluationTab',
+            'agents': 'aiAgentsTab',
+            'datasets': 'datasetsTab'
+        };
+        
+        this.initializeNavigation();
+    }
+
+    async initializeNavigation() {
+        await this.loadUserInfo();
+        this.initializeEventListeners();
+        this.handleInitialRoute();
+    }
+
+    async loadUserInfo() {
+        try {
+            const response = await getCurrentSession();
+            if (response.ok) {
+                const data = await response.json();
+                const user = data.user;
+                this.updateUserInfo(user);
+            } else {
+                window.location.href = '/login';
+            }
+        } catch (error) {
+            console.error('Failed to load user info:', error);
+            UIHelper.showAlert('Failed to load user information');
+            window.location.href = '/login';
+        }
+    }
+
+    initializeEventListeners() {
+        // Tab navigation
+        this.tabItems.forEach(item => {
+            item.addEventListener('click', (e) => this.handleTabClick(e));
+        });
+
+        // Sign out functionality
+        this.signOutBtn.addEventListener('click', async () => {
+            try {
+                const response = await logout();
+                if (response.ok) {
+                    window.location.href = '/login';
+                } else {
+                    UIHelper.showAlert('Logout failed');
+                }
+            } catch (error) {
+                console.error('Logout error:', error);
+                UIHelper.showAlert('Failed to logout');
+            }
+        });
+
+        // Mobile menu toggle
+        if (this.menuToggle) {
+            this.menuToggle.addEventListener('click', () => {
+                this.sidenav.classList.toggle('active');
+            });
+
+            // Close menu when clicking outside
+            document.addEventListener('click', (e) => {
+                if (!this.sidenav.contains(e.target) && 
+                    !this.menuToggle.contains(e.target) && 
+                    this.sidenav.classList.contains('active')) {
+                    this.sidenav.classList.remove('active');
+                }
+            });
+        }
+
+        // Handle browser back/forward
+        window.addEventListener('popstate', () => {
+            this.handleInitialRoute();
+        });
+    }
+
+    handleInitialRoute() {
+        // Get hash from URL
+        const hash = window.location.hash.slice(1);
+        
+        // If hash starts with dataset, activate datasets tab
+        if (hash.startsWith('dataset')) {
+            const tabId = this.tabMapping['datasets'];
+            this.activateTab(tabId);
+            
+            // Update sidenav selection
+            const datasetsTab = document.querySelector('.sidenav__item[data-tab="datasets"]');
+            if (datasetsTab) {
+                this.tabItems.forEach(tab => tab.classList.remove('active'));
+                datasetsTab.classList.add('active');
+            }
+        } else {
+            // Original behavior for other routes
+            const tabId = this.tabMapping[hash] || this.tabMapping['playground'];
+            this.activateTab(tabId);
+            
+            const sidenavItem = document.querySelector(`.sidenav__item[data-tab="${hash || 'playground'}"]`);
+            if (sidenavItem) {
+                this.tabItems.forEach(tab => tab.classList.remove('active'));
+                sidenavItem.classList.add('active');
+            }
+        }
+    }
+
+    handleTabClick(e) {
+        e.preventDefault();
+        
+        const clickedTab = e.currentTarget;
+        const tabName = clickedTab.dataset.tab;
+        const tabId = this.tabMapping[tabName];
+
+        if (tabId) {
+            // Update URL hash without triggering popstate
+            history.pushState(null, '', `#${tabName}`);
+            
+            // Activate the tab
+            this.activateTab(tabId);
+            
+            // Update sidenav selection
+            this.tabItems.forEach(tab => tab.classList.remove('active'));
+            clickedTab.classList.add('active');
+        }
+    }
+
+    activateTab(tabId) {
+        this.tabContents.forEach(content => content.classList.remove('active'));
+        const targetTab = document.getElementById(tabId);
+        if (targetTab) {
+            targetTab.classList.add('active');
+        }
+    }
+
+    updateUserInfo(user) {
+        if (!user) {
+            UIHelper.showAlert('User information not available');
+            return;
+        }
+        
+        this.userNameElement.textContent = user.name || 'Unknown User';
+        if (user.picture) {
+            this.userAvatarElement.src = user.picture;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/panel.js b/src/static/js/components/panel.js
deleted file mode 100644
index 82d8877..0000000
--- a/src/static/js/components/panel.js
+++ /dev/null
@@ -1,53 +0,0 @@
-import { FormHelper } from '../utils/formHelper.js';
-
-export class Panel {
-    constructor() {
-        this.panel = document.getElementById('slidingPanel');
-        this.overlay = document.getElementById('overlay');
-        this.closeBtn = document.getElementById('closePanelBtn');
-        this.title = document.getElementById('panelTitle');
-        this.form = document.getElementById('panelForm');
-
-        this.closeBtn.onclick = () => this.close();
-        this.overlay.onclick = () => this.close();
-    }
-
-    show(title, fields, submitCallback, closeAfterSubmit = true) {
-        this.title.textContent = title;
-        this.form.innerHTML = '';
-        
-        fields.forEach(field => {
-            const label = document.createElement('label');
-            label.className = 'form__label';
-            label.textContent = field.label;
-            let input = FormHelper.createInput(field);
-            
-            label.appendChild(input);
-            this.form.appendChild(label);
-        });
-
-        const submitBtn = document.createElement('button');
-        submitBtn.className = 'button button--primary panel__save-btn';
-        submitBtn.textContent = title === 'Add Dataset' ? 'Generate Questions' : 'Save Character';
-        submitBtn.onclick = (e) => {
-            e.preventDefault();
-            const formData = new FormData(this.form);
-            const data = Object.fromEntries(formData.entries());
-            submitCallback(data);
-            if (closeAfterSubmit) {
-                this.close();
-            }
-        };
-        this.form.appendChild(submitBtn);
-
-        this.panel.classList.add('panel--open');
-        this.overlay.classList.add('overlay--active');
-        document.body.classList.add('body--panel-open');
-    }
-
-    close() {
-        this.panel.classList.remove('panel--open');
-        this.overlay.classList.remove('overlay--active');
-        document.body.classList.remove('body--panel-open');
-    }
-}
\ No newline at end of file
diff --git a/src/static/js/components/playground/chatManager.js b/src/static/js/components/playground/chatManager.js
new file mode 100644
index 0000000..d7cba86
--- /dev/null
+++ b/src/static/js/components/playground/chatManager.js
@@ -0,0 +1,41 @@
+export class ChatManager {
+    constructor(container) {
+        this.container = container;
+        this.messagesContainer = container.querySelector('.chat-messages');
+        this.chatHistory = [];
+        this.isChatStarted = false;
+    }
+
+    start(initialMessage) {
+        if (!initialMessage.trim()) {
+            throw new Error('Initial message is required');
+        }
+
+        this.container.style.display = 'block';
+        this.addMessage('user', initialMessage);
+        this.addMessage('assistant', 'This is a simulated AI response.');
+        this.isChatStarted = true;
+    }
+
+    addMessage(role, content) {
+        const messageElement = document.createElement('div');
+        messageElement.className = `chat-message chat-message--${role}`;
+        messageElement.innerHTML = `
+            <div class="chat-message__avatar">
+                <i class="material-icons">${role === 'user' ? 'person' : 'smart_toy'}</i>
+            </div>
+            <div class="chat-message__content">${content}</div>
+        `;
+        this.messagesContainer.appendChild(messageElement);
+        
+        this.chatHistory.push({ role, content });
+        this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
+    }
+
+    async handleNewMessage(message) {
+        if (!this.isChatStarted || !message.trim()) return;
+        
+        this.addMessage('user', message);
+        this.addMessage('assistant', 'This is a simulated AI response.');
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/playground/playground.js b/src/static/js/components/playground/playground.js
new file mode 100644
index 0000000..d4c963d
--- /dev/null
+++ b/src/static/js/components/playground/playground.js
@@ -0,0 +1,90 @@
+import { EvaluationManager } from '../evaluation/evaluationManager.js';
+import { PromptCard } from './promptCard.js';
+import { UIHelper } from '../../utils/uiHelper.js';
+
+export class Playground {
+    constructor() {
+        this.agents = new Map();
+        this.initializeElements();
+        this.initializeManagers();
+        this.initializeEventListeners();
+        this.addInitialPromptCard();
+    }
+
+    initializeElements() {
+        this.promptsContainer = document.getElementById('promptsContainer');
+        this.addPromptBtn = document.getElementById('addPromptBtn');
+        this.clearBtn = document.getElementById('clearEvaluationBtn');
+    }
+
+    initializeManagers() {
+        this.evaluationManager = new EvaluationManager();
+    }
+
+    initializeEventListeners() {
+        this.addPromptBtn.onclick = () => this.addPromptCard();
+        this.clearBtn.onclick = () => this.clear();
+        this.initializePromptListeners();
+        
+        // Listen for agents updates from AiAgentManager only
+        document.addEventListener('agents-updated', (event) => {
+            if (event.detail.source === 'aiAgentManager') {
+                this.updateAgents(event.detail.agents);
+            }
+        });
+    }
+
+    initializePromptListeners() {
+        this.promptsContainer.addEventListener('click', (e) => {
+            if (e.target.closest('.remove-prompt')) {
+                const card = e.target.closest('.prompt-card');
+                if (this.promptsContainer.children.length > 1) {
+                    card.remove();
+                }
+            }
+        });
+    }
+
+    addInitialPromptCard() {
+        this.addPromptCard();
+    }
+
+    addPromptCard() {
+        const promptCard = new PromptCard();
+        promptCard.element.__promptCard = promptCard;
+        this.promptsContainer.appendChild(promptCard.element);
+
+        if (this.agents.size > 0) {
+            this.notifyPromptCardAgents();
+        }
+    }
+
+    updateAgents(agents) {
+        this.agents.clear();
+        Object.entries(agents).forEach(([id, agent]) => {
+            this.agents.set(id, agent);
+        });
+        this.notifyPromptCardAgents();
+    }
+
+    notifyPromptCardAgents() {
+        const agentsObj = Object.fromEntries(this.agents);
+        // Add source to differentiate from AiAgentManager events
+        document.dispatchEvent(new CustomEvent('agents-updated', {
+            detail: { 
+                agents: agentsObj,
+                source: 'playground'
+            }
+        }));
+    }
+
+    clear() {
+        while (this.promptsContainer.children.length > 1) {
+            this.promptsContainer.lastChild.remove();
+        }
+        const firstPrompt = this.promptsContainer.querySelector('.prompt-template');
+        if (firstPrompt) firstPrompt.value = '';
+        
+        this.evaluationManager.clear();
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/playground/promptCard.js b/src/static/js/components/playground/promptCard.js
new file mode 100644
index 0000000..0c4aa66
--- /dev/null
+++ b/src/static/js/components/playground/promptCard.js
@@ -0,0 +1,282 @@
+import { PromptSettings } from "./promptSettings.js";
+import { AgentMenu } from "../agents/agentMenu.js";
+import { ChatManager } from "./chatManager.js";
+import { VariableHelper } from "../../utils/variableHelper.js";
+import { UIHelper } from "../../utils/uiHelper.js";
+
+export class PromptCard {
+    constructor() {
+        this.initializeElements();
+        this.initializeComponents();
+        this.initializeEventListeners();
+        this.variables = new Set();
+    }
+
+    initializeElements() {
+        this.element = document.createElement('div');
+        this.element.className = 'prompt-card';
+        this.render();
+        
+        this.dynamicInputs = this.element.querySelector('.dynamic-inputs');
+        this.systemPromptInput = this.element.querySelector('.prompt-template');
+        this.userPromptInput = this.element.querySelector('.user-prompt-template');
+        this.agentNameInput = this.element.querySelector('.agent-name');
+        this.chatContainer = this.element.querySelector('.chat-container');
+        this.userMessageInput = this.element.querySelector('.user-prompt');
+    }
+
+    initializeComponents() {
+        this.promptSettings = new PromptSettings();
+        this.agentMenu = new AgentMenu(this.element, this.handleAgentAction.bind(this));
+        this.chatManager = new ChatManager(this.chatContainer);
+        this.agents = {};
+    }
+
+    initializeEventListeners() {
+        // Button click handlers
+        this.element.querySelector('.save-prompt').onclick = () => this.handleSave();
+        this.element.querySelector('.load-agent').onclick = () => this.agentMenu.toggle();
+        this.element.querySelector('.settings-prompt').onclick = () => this.promptSettings.show();
+        this.element.querySelector('.start-chat').onclick = () => this.startChat();
+        this.element.querySelector('.run-prompt').onclick = () => this.handleRunPrompt();
+        
+        // Input change handlers
+        this.systemPromptInput.addEventListener('input', () => this.updateInputFields());
+        this.userPromptInput.addEventListener('input', () => this.updateInputFields());
+        
+        // Chat input handler
+        this.userMessageInput.addEventListener('keypress', async (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                await this.handleRunPrompt();
+            }
+        });
+
+        // Agent menu handlers
+        this.element.querySelector('.agent-menu').onclick = async (e) => await this.agentMenu.handleClick(e);
+        document.addEventListener('click', (e) => {
+            if (!this.element.querySelector('.agent-selector').contains(e.target)) {
+                this.agentMenu.close();
+            }
+        });
+
+        // Global event handlers
+        document.addEventListener('agents-updated', (e) => {
+            this.agents = e.detail.agents;
+            this.agentMenu.updateAgentSelect(this.agents);
+        });
+        document.addEventListener('load-agent', (e) => this.fillAgentData(e.detail.agent));
+        document.addEventListener('load-variant', (e) => this.fillVariantData(e.detail.agent, e.detail.variant));
+    }
+
+    async handleAgentAction(action) {
+        if (!action) return;
+
+        const [type, agentId, variantId] = action.split(':');
+        const agent = this.agents[agentId];
+        if (!agent) return;
+
+        if (type === 'load') {
+            this.fillAgentData(agent);
+        } else if (type === 'variant') {
+            this.fillVariantData(agent, agent.variants[variantId]);
+        }
+
+        this.agentMenu.close();
+    }
+
+    fillAgentData(agent) {
+        this.setContent(agent.prompt[0].content);
+        const userPrompt = agent.prompt.find(p => p.role === 'user');
+        this.setUserPrompt(userPrompt ? userPrompt.content : '');
+        
+        this.promptSettings.updateSettings(agent.config);
+        this.updateInputFields();
+        this.updateVariablePersistence(agent.included_variables);
+        this.agentNameInput.value = agent.name;
+    }
+
+    fillVariantData(agent, variant) {
+        this.fillAgentData(agent);
+        this.fillVariableValues(variant.variables);
+    }
+
+    updateVariablePersistence(includedVariables = []) {
+        const checkboxes = this.element.querySelectorAll('.variable-persistence');
+        checkboxes.forEach(checkbox => {
+            const variable = checkbox.dataset.variable;
+            checkbox.checked = includedVariables.includes(variable);
+        });
+    }
+
+    fillVariableValues(variables = {}) {
+        Object.entries(variables).forEach(([key, value]) => {
+            const input = this.element.querySelector(`#input_${key}`);
+            if (input) input.value = value;
+        });
+    }
+
+    generateInputFields() {
+        this.dynamicInputs.innerHTML = '';
+        
+        if (this.variables.size > 0) {
+            const inputsContainer = document.createElement('div');
+            inputsContainer.className = 'card-inputs';
+            
+            const systemVariables = VariableHelper.extractVariables(this.getContent());
+            
+            this.variables.forEach(variable => {
+                inputsContainer.appendChild(this.createInputGroup(variable, systemVariables.has(variable)));
+            });
+            
+            this.dynamicInputs.appendChild(inputsContainer);
+        }
+    }
+
+    createInputGroup(variable, isSystemVariable) {
+        const inputGroup = document.createElement('div');
+        inputGroup.className = 'input-group';
+        inputGroup.innerHTML = `
+            <label for="input_${variable}">${variable}:</label>
+            <div class="input-group__content">
+                <input type="text" 
+                    id="input_${variable}" 
+                    class="form__input" 
+                    placeholder="Enter value for ${variable}">
+                <div class="input-group__actions">
+                    <input type="checkbox" 
+                        id="save_${variable}" 
+                        class="variable-persistence"
+                        data-variable="${variable}"
+                        ${isSystemVariable ? 'checked' : ''}>
+                    <label for="save_${variable}" class="checkbox-label">Save</label>
+                </div>
+            </div>
+        `;
+        return inputGroup;
+    }
+
+    async handleSave() {
+        const name = this.agentNameInput.value.trim();
+        if (!name) {
+            UIHelper.showAlert('Please enter an agent name');
+            return;
+        }
+
+        const agentData = this.createAgentData(name);
+        document.dispatchEvent(new CustomEvent('save-agent', { detail: { agent: agentData } }));
+        UIHelper.showToast('Agent saved successfully');
+    }
+
+    createAgentData(name) {
+        const includedVariables = Array.from(
+            this.element.querySelectorAll('.variable-persistence:checked')
+        ).map(checkbox => checkbox.dataset.variable);
+
+        return {
+            name,
+            prompt: [
+                { role: 'system', content: this.getContent() },
+                { role: 'user', content: this.getUserPrompt() }
+            ],
+            config: this.promptSettings.getSettings(),
+            included_variables: includedVariables
+        };
+    }
+
+    updateInputFields() {
+        const systemVariables = VariableHelper.extractVariables(this.getContent());
+        const userVariables = VariableHelper.extractVariables(this.getUserPrompt());
+        this.variables = VariableHelper.combineVariables([...systemVariables], [...userVariables]);
+        this.generateInputFields();
+    }
+
+    startChat() {
+        const userPrompt = this.getUserPrompt();
+        if (!userPrompt) {
+            UIHelper.showAlert('Please enter a user prompt to start the chat');
+            return;
+        }
+
+        try {
+            this.chatManager.start(userPrompt);
+        } catch (error) {
+            UIHelper.showAlert(error.message);
+        }
+    }
+
+    async handleRunPrompt() {
+        const message = this.userMessageInput.value.trim();
+        await this.chatManager.handleNewMessage(message);
+        this.userMessageInput.value = '';
+    }
+
+    getContent() {
+        return this.systemPromptInput.value;
+    }
+
+    setContent(content) {
+        this.systemPromptInput.value = content;
+    }
+
+    getUserPrompt() {
+        return this.userPromptInput.value.trim();
+    }
+
+    setUserPrompt(content) {
+        this.userPromptInput.value = content;
+    }
+
+    // Keep the render method at the bottom as it's just template definition
+    render() {
+        this.element.innerHTML = `
+            <div class="prompt-header">
+                <label>System Prompt:</label>
+                <div class="agent-selector">
+                    <button class="button load-agent">Load Agent</button>
+                    <div class="agent-menu" style="display: none;"></div>
+                </div>
+                <button class="button button--icon settings-prompt" title="Prompt Settings">
+                    <i class="material-icons">settings</i>
+                </button>
+                <button class="button button--icon remove-prompt">
+                    <i class="material-icons">close</i>
+                </button>
+            </div>
+            <textarea class="form__input prompt-template" 
+                placeholder="Enter your system prompt. Use {variable_name} for dynamic inputs..."></textarea>
+            
+            <div class="prompt-header">
+                <label>User Prompt:</label>
+            </div>
+            <textarea class="form__input user-prompt-template" 
+                placeholder="Enter your initial message..."></textarea>
+            
+            <div class="dynamic-inputs"></div>
+
+            <div class="prompt-actions">
+                <button class="start-chat button button--primary">
+                    Start Chat
+                </button>
+            </div>
+
+            <div class="chat-container" style="display: none;">
+                <div class="chat-messages"></div>
+                <div class="chat-input-container">
+                    <textarea class="form__input user-prompt" 
+                        placeholder="Enter your message..."></textarea>
+                    <button class="run-prompt button button--primary">
+                        <i class="material-icons">send</i>
+                    </button>
+                </div>
+            </div>
+
+            <div class="prompt-card__footer">
+                <input type="text" class="form__input agent-name" placeholder="Enter agent name">
+                <button class="save-prompt button button--secondary">
+                    <i class="material-icons">save</i> Save
+                </button>
+            </div>
+        `;
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/playground/promptSettings.js b/src/static/js/components/playground/promptSettings.js
new file mode 100644
index 0000000..76f0896
--- /dev/null
+++ b/src/static/js/components/playground/promptSettings.js
@@ -0,0 +1,117 @@
+import { FormHelper } from '../../utils/formHelper.js';
+
+export class PromptSettings {
+    constructor() {
+        this.createModal();
+        this.models = {};
+        this.fetchModels();
+        this.settings = {
+            model: 'gpt-4o',
+            temperature: 0.6,
+            max_tokens: 2000
+        };
+    }
+
+    async fetchModels() {
+        try {
+            const response = await fetch('/api/config/models');
+            this.models = await response.json();
+        } catch (error) {
+            console.error('Failed to fetch models:', error);
+        }
+    }
+
+    createModal() {
+        this.modal = document.createElement('div');
+        this.modal.className = 'settings-popup';
+        document.body.appendChild(this.modal);
+    }
+
+    getSettings() {
+        return { ...this.settings };
+    }
+
+    updateSettings(newSettings) {
+        this.settings = { ...newSettings };
+    }
+
+    show() {
+        const modelOptions = Object.entries(this.models).flatMap(([provider, models]) => 
+            models.map(model => ({
+                value: model.id,
+                label: `${model.name} (${provider})`
+            }))
+        );
+
+        const fields = [
+            {
+                label: 'Model',
+                type: 'select',
+                name: 'model',
+                options: modelOptions,
+                value: this.settings.model
+            },
+            {
+                label: 'Temperature',
+                type: 'range',
+                name: 'temperature',
+                min: 0,
+                max: 1,
+                step: 0.1,
+                value: this.settings.temperature
+            },
+            {
+                label: 'Max Tokens',
+                type: 'number',
+                name: 'max_tokens',
+                value: this.settings.max_tokens,
+                min: 1
+            }
+        ];
+
+        this.modal.innerHTML = `
+            <div class="settings-content">
+                <h3>Prompt Settings</h3>
+                <form class="settings-form"></form>
+                <div class="settings-actions">
+                    <button class="button button--secondary" onclick="this.closest('.settings-popup').style.display='none'">Close</button>
+                </div>
+            </div>
+        `;
+
+        const form = this.modal.querySelector('.settings-form');
+        fields.forEach(field => {
+            const formGroup = document.createElement('div');
+            formGroup.className = 'form-group';
+            
+            const label = document.createElement('label');
+            label.className = 'form__label';
+            label.textContent = field.label;
+            
+            const input = FormHelper.createInput(field);
+
+            // Set initial value
+            input.value = this.settings[field.name];
+
+            const inputElement = field.type === 'range' ? input.querySelector('input') : input;
+
+            inputElement.addEventListener('input', () => {
+                const newValue = field.type === 'range' ? parseFloat(inputElement.value) : 
+                            field.type === 'number' ? parseInt(inputElement.value) : 
+                            inputElement.value;
+                this.settings[field.name] = newValue;
+            });
+            
+            formGroup.appendChild(label);
+            formGroup.appendChild(input);
+            form.appendChild(formGroup);
+        });
+
+        this.modal.style.display = 'flex';
+        
+        // Close on outside click
+        this.modal.onclick = (e) => {
+            if (e.target === this.modal) this.modal.style.display = 'none';
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/promptCard.js b/src/static/js/components/promptCard.js
new file mode 100644
index 0000000..fb3f380
--- /dev/null
+++ b/src/static/js/components/promptCard.js
@@ -0,0 +1,195 @@
+import { PromptSettings } from "./promptSettings.js";
+
+export class PromptCard {
+    constructor(agents) {
+        this.agents = agents;
+        this.element = document.createElement('div');
+        this.element.className = 'prompt-card';
+        this.promptSettings = new PromptSettings();
+        this.render();
+        this.initializeEventListeners();
+
+        this.chatHistory = [];
+        this.isChatStarted = false;
+    }
+
+    render() {
+        this.element.innerHTML = `
+            <div class="prompt-header">
+                <label>System Prompt:</label>
+                <select class="form__input prompt-select">
+                    <option value="">Load AI Agent</option>
+                </select>
+                <button class="button button--icon settings-prompt" title="Prompt Settings">
+                    <i class="material-icons">settings</i>
+                </button>
+                <button class="button button--icon remove-prompt">
+                    <i class="material-icons">close</i>
+                </button>
+            </div>
+            <textarea class="form__input prompt-template" 
+                placeholder="Enter your system prompt. Use {variable_name} for dynamic inputs..."></textarea>
+            
+            <div class="prompt-header">
+                <label>User Prompt:</label>
+            </div>
+            <textarea class="form__input user-prompt-template" 
+                placeholder="Enter your initial message..."></textarea>
+            
+            <div class="prompt-actions">
+                <button class="start-chat button button--primary">
+                    Start Chat
+                </button>
+            </div>
+
+            <div class="chat-container" style="display: none;">
+                <div class="chat-messages"></div>
+                <div class="chat-input-container">
+                    <textarea class="form__input user-prompt" 
+                        placeholder="Enter your message..."></textarea>
+                    <button class="run-prompt button button--primary">
+                        <i class="material-icons">send</i>
+                    </button>
+                </div>
+            </div>
+
+            <div class="prompt-card__footer">
+                <input type="text" class="form__input agent-name" placeholder="Enter agent name">
+                <button class="save-prompt button button--secondary">
+                    <i class="material-icons">save</i> Save
+                </button>
+            </div>
+        `;
+    }
+
+    initializeEventListeners() {
+        this.element.querySelector('.save-prompt').onclick = () => this.saveAsAgent();
+        this.element.querySelector('.prompt-select').onchange = (e) => this.loadAgent(e.target.value);
+        this.element.querySelector('.settings-prompt').onclick = () => this.promptSettings.show();
+        this.element.querySelector('.start-chat').onclick = () => this.startChat();
+        this.element.querySelector('.run-prompt').onclick = () => this.handleRunPrompt();
+        
+        // Add enter key support for chat input
+        this.element.querySelector('.user-prompt').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                this.handleRunPrompt();
+            }
+        });
+    }
+
+    startChat() {
+        const userPrompt = this.element.querySelector('.user-prompt-template').value.trim();
+        if (!userPrompt) {
+            alert('Please enter a user prompt to start the chat');
+            return;
+        }
+
+        // Show chat container
+        this.element.querySelector('.chat-container').style.display = 'block';
+        
+        // Add AI response to initial prompt
+        this.addChatMessage('assistant', 'This is a simulated AI response.');
+
+        this.isChatStarted = true;
+    }
+
+    handleRunPrompt() {
+        if (!this.isChatStarted) return;
+        
+        const userPrompt = this.element.querySelector('.user-prompt').value.trim();
+        if (!userPrompt) return;
+
+        this.addChatMessage('user', userPrompt);
+        this.addChatMessage('assistant', 'This is a simulated AI response.');
+        
+        this.element.querySelector('.user-prompt').value = '';
+    }
+
+    addChatMessage(role, content) {
+        const messagesContainer = this.element.querySelector('.chat-messages');
+        const messageElement = document.createElement('div');
+        messageElement.className = `chat-message chat-message--${role}`;
+        messageElement.innerHTML = `
+            <div class="chat-message__avatar">
+                <i class="material-icons">${role === 'user' ? 'person' : 'smart_toy'}</i>
+            </div>
+            <div class="chat-message__content">${content}</div>
+        `;
+        messagesContainer.appendChild(messageElement);
+        
+        // Store in history
+        this.chatHistory.push({ role, content });
+        
+        // Scroll to bottom
+        messagesContainer.scrollTop = messagesContainer.scrollHeight;
+    }
+
+    async loadAgent(agentId) {
+        if (!agentId) return;
+
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            this.setContent(agent.prompt[0].content);
+            this.promptSettings.updateSettings(agent.config);
+            
+            this.element.dispatchEvent(new CustomEvent('prompt-updated', {
+                bubbles: true
+            }));
+        }
+    }
+
+    async saveAsAgent() {
+        const name = this.getName();
+        if (!name) return;
+
+        const agentData = {
+            name,
+            prompt: [{
+                role: 'system',
+                content: this.getContent()
+            }],
+            config: this.promptSettings.getSettings()
+        };
+
+        document.dispatchEvent(new CustomEvent('save-agent', {
+            detail: { agent: agentData }
+        }));
+
+        this.showToast('Agent saved successfully');
+    }
+
+    getName() {
+        const name = this.element.querySelector('.agent-name').value.trim();
+        if (!name) {
+            alert('Please enter an agent name');
+            return null;
+        }
+        return name;
+    }
+
+    getContent() {
+        return this.element.querySelector('.prompt-template').value;
+    }
+
+    setContent(content) {
+        this.element.querySelector('.prompt-template').value = content;
+    }
+
+    showToast(message) {
+        const toast = document.createElement('div');
+        toast.className = 'toast toast--success';
+        toast.textContent = message;
+        
+        document.body.appendChild(toast);
+        
+        // Trigger animation
+        setTimeout(() => toast.classList.add('toast--visible'), 100);
+        
+        // Remove after 3 seconds
+        setTimeout(() => {
+            toast.classList.remove('toast--visible');
+            setTimeout(() => toast.remove(), 300); // Remove after fade animation
+        }, 3000);
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/components/promptSettings.js b/src/static/js/components/promptSettings.js
new file mode 100644
index 0000000..b5e71e2
--- /dev/null
+++ b/src/static/js/components/promptSettings.js
@@ -0,0 +1,117 @@
+import { FormHelper } from '../utils/formHelper.js';
+
+export class PromptSettings {
+    constructor() {
+        this.createModal();
+        this.models = {};
+        this.fetchModels();
+        this.settings = {
+            model: 'gpt-4o',
+            temperature: 0.6,
+            max_tokens: 2000
+        };
+    }
+
+    async fetchModels() {
+        try {
+            const response = await fetch('/api/config/models');
+            this.models = await response.json();
+        } catch (error) {
+            console.error('Failed to fetch models:', error);
+        }
+    }
+
+    createModal() {
+        this.modal = document.createElement('div');
+        this.modal.className = 'settings-popup';
+        document.body.appendChild(this.modal);
+    }
+
+    getSettings() {
+        return { ...this.settings };
+    }
+
+    updateSettings(newSettings) {
+        this.settings = { ...newSettings };
+    }
+
+    show() {
+        const modelOptions = Object.entries(this.models).flatMap(([provider, models]) => 
+            models.map(model => ({
+                value: model.id,
+                label: `${model.name} (${provider})`
+            }))
+        );
+
+        const fields = [
+            {
+                label: 'Model',
+                type: 'select',
+                name: 'model',
+                options: modelOptions,
+                value: this.settings.model
+            },
+            {
+                label: 'Temperature',
+                type: 'range',
+                name: 'temperature',
+                min: 0,
+                max: 1,
+                step: 0.1,
+                value: this.settings.temperature
+            },
+            {
+                label: 'Max Tokens',
+                type: 'number',
+                name: 'max_tokens',
+                value: this.settings.max_tokens,
+                min: 1
+            }
+        ];
+
+        this.modal.innerHTML = `
+            <div class="settings-content">
+                <h3>Prompt Settings</h3>
+                <form class="settings-form"></form>
+                <div class="settings-actions">
+                    <button class="button button--secondary" onclick="this.closest('.settings-popup').style.display='none'">Close</button>
+                </div>
+            </div>
+        `;
+
+        const form = this.modal.querySelector('.settings-form');
+        fields.forEach(field => {
+            const formGroup = document.createElement('div');
+            formGroup.className = 'form-group';
+            
+            const label = document.createElement('label');
+            label.className = 'form__label';
+            label.textContent = field.label;
+            
+            const input = FormHelper.createInput(field);
+
+            // Set initial value
+            input.value = this.settings[field.name];
+
+            const inputElement = field.type === 'range' ? input.querySelector('input') : input;
+
+            inputElement.addEventListener('input', () => {
+                const newValue = field.type === 'range' ? parseFloat(inputElement.value) : 
+                            field.type === 'number' ? parseInt(inputElement.value) : 
+                            inputElement.value;
+                this.settings[field.name] = newValue;
+            });
+            
+            formGroup.appendChild(label);
+            formGroup.appendChild(input);
+            form.appendChild(formGroup);
+        });
+
+        this.modal.style.display = 'flex';
+        
+        // Close on outside click
+        this.modal.onclick = (e) => {
+            if (e.target === this.modal) this.modal.style.display = 'none';
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/main.js b/src/static/js/main.js
index baeffc2..40f877c 100644
--- a/src/static/js/main.js
+++ b/src/static/js/main.js
@@ -1,11 +1,11 @@
-import { CharacterManager } from './components/characterManager.js';
-import { DatasetManager } from './components/datasetManager.js';
-import { EvaluationManager } from './components/evaluationManager.js';
-import { initializeHeader } from './components/header.js';
+import { AiAgentManager } from './components/agents/aiAgentManager.js';
+import { DatasetManager } from './components/dataset/datasetManager.js';
+import { Playground } from './components/playground/playground.js';
+import { Navigation } from './components/navigation/navigation.js';
 
 document.addEventListener('DOMContentLoaded', () => {
-    initializeHeader();
-    new CharacterManager();
+    new Navigation();
+    new AiAgentManager();
     new DatasetManager();
-    new EvaluationManager();
+    new Playground();
 });
\ No newline at end of file
diff --git a/src/static/js/utils/formHelper.js b/src/static/js/utils/formHelper.js
index 61eabda..2b99f1e 100644
--- a/src/static/js/utils/formHelper.js
+++ b/src/static/js/utils/formHelper.js
@@ -48,7 +48,7 @@ export const FormHelper = {
         input.min = field.min;
         input.max = field.max;
         input.step = field.step;
-        input.value = (field.max - field.min) / 2;
+        input.value = field.value;
         input.className = 'form__range';
 
         const rangeValue = document.createElement('span');
diff --git a/src/static/js/utils/uiHelper.js b/src/static/js/utils/uiHelper.js
new file mode 100644
index 0000000..3d9a2b3
--- /dev/null
+++ b/src/static/js/utils/uiHelper.js
@@ -0,0 +1,19 @@
+export class UIHelper {
+    static showToast(message, type = 'success') {
+        const toast = document.createElement('div');
+        toast.className = `toast toast--${type}`;
+        toast.textContent = message;
+        
+        document.body.appendChild(toast);
+        
+        setTimeout(() => toast.classList.add('toast--visible'), 100);
+        setTimeout(() => {
+            toast.classList.remove('toast--visible');
+            setTimeout(() => toast.remove(), 300);
+        }, 3000);
+    }
+
+    static showAlert(message) {
+        alert(message); // Could be replaced with a custom modal later
+    }
+}
\ No newline at end of file
diff --git a/src/static/js/utils/variableHelper.js b/src/static/js/utils/variableHelper.js
new file mode 100644
index 0000000..89f2c25
--- /dev/null
+++ b/src/static/js/utils/variableHelper.js
@@ -0,0 +1,11 @@
+export class VariableHelper {
+    static extractVariables(template) {
+        const regex = /{([^}]+)}/g;
+        const matches = [...template.matchAll(regex)];
+        return new Set(matches.map(match => match[1]));
+    }
+
+    static combineVariables(...variableSets) {
+        return new Set([...variableSets].flat());
+    }
+}
\ No newline at end of file
diff --git a/src/templates/components/main-content.html b/src/templates/components/main-content.html
new file mode 100644
index 0000000..843f83a
--- /dev/null
+++ b/src/templates/components/main-content.html
@@ -0,0 +1,78 @@
+<button class="menu-toggle" id="menuToggle">
+    <i class="material-icons">menu</i>
+</button>
+
+<main class="main-content">
+    <!-- Evaluation Tab -->
+    <div id="evaluationTab" class="tab-content active">
+        <div class="content-header">
+            <h1>Playground</h1>
+        </div>
+        
+        <!-- Prompts Section -->
+        <div class="prompts-header">
+            <h2>Prompts</h2>
+            <button id="addPromptBtn" class="button button--secondary">
+                <i class="material-icons">add</i> Add Prompt
+            </button>
+        </div>
+
+        <div class="prompts-scroll-container">
+            <div id="promptsContainer" class="prompts-container">
+                 <!-- PromptCards will appear here -->
+            </div>
+        </div>
+
+        <!-- Dynamic Inputs Section -->
+        <div id="dynamicInputs" class="dynamic-inputs-section">
+            <!-- Dynamic input fields will appear here -->
+        </div>
+
+        <!-- Controls Section -->
+        <div class="controls-section">
+            <select id="evalDatasetSelect" class="form__input">
+                <option value="">Select a dataset</option>
+            </select>
+            <button id="evaluateBtn" class="button button--primary">
+                <i class="material-icons">play_arrow</i> Evaluate
+            </button>
+            <button id="clearEvaluationBtn" class="button button--primary">
+                <i class="material-icons">delete</i> Clear
+            </button>
+        </div>
+
+        <div id="evaluationResults"></div>
+    </div>
+    
+    <!-- Characters Tab -->
+    <div id="aiAgentsTab" class="tab-content">
+        <div class="content-header">
+            <h1>AI Agents</h1>
+        </div>
+        <div id="agentList" class="card-grid">
+            <!-- AI Agents will be loaded here -->
+        </div>
+    </div>
+
+    <!-- Datasets Tab -->
+    <div id="datasetsTab" class="tab-content">
+        <!-- This is the list view -->
+        <div id="datasetsListView">
+            <div class="content-header">
+                <h1>Datasets</h1>
+                <button id="addDatasetBtn" class="button button--primary">
+                    <i class="material-icons">add</i>
+                    Add Dataset
+                </button>
+            </div>
+            <div id="datasetList" class="card-grid">
+                <!-- Datasets will be loaded here -->
+            </div>
+        </div>
+    
+        <!-- This is the new editor view -->
+        <div id="datasetEditor" class="dataset-editor" style="display: none">
+            <!-- Editor content will be rendered by JavaScript -->
+        </div>
+    </div>
+</main>
diff --git a/src/templates/components/sidenav.html b/src/templates/components/sidenav.html
new file mode 100644
index 0000000..4431599
--- /dev/null
+++ b/src/templates/components/sidenav.html
@@ -0,0 +1,28 @@
+<nav class="sidenav">
+    <div class="sidenav__user">
+        <img id="userAvatar" src="{{ url_for('static', filename='images/default-avatar.png') }}" alt="User Avatar">
+        <span id="userName">Loading...</span>
+    </div>
+    
+    <div class="sidenav__menu">
+        <a href="#playground" class="sidenav__item active" data-tab="playground">
+            <i class="material-icons">extension</i>
+            Playground
+        </a>
+        <a href="#agents" class="sidenav__item" data-tab="agents">
+            <i class="material-icons">smart_toy</i>
+            AI Agents
+        </a>
+        <a href="#datasets" class="sidenav__item" data-tab="datasets">
+            <i class="material-icons">dataset</i>
+            Datasets
+        </a>
+    </div>
+
+    <div class="sidenav__footer">
+        <button id="signOutBtn" class="sidenav__signout">
+            <i class="material-icons">logout</i>
+            Sign Out
+        </button>
+    </div>
+</nav>
\ No newline at end of file
diff --git a/src/templates/index.html b/src/templates/index.html
index 49c8e2c..8cbfbb3 100644
--- a/src/templates/index.html
+++ b/src/templates/index.html
@@ -3,72 +3,20 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Character and Dataset Manager</title>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">
+    <title>ProBack</title>
+    <!-- Material Icons -->
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+    <!-- Google Fonts -->
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <!-- Main CSS -->
     <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
 </head>
 <body>
-    <div class="container">
-        <header>
-            <div class="header-content">
-                <h1><i class="fas fa-robot"></i> Character and Dataset Manager</h1>
-                <div class="user-info">
-                    <span id="userName"></span>
-                    <button id="logoutButton" class="button button--secondary">Logout</button>
-                </div>
-            </div>
-        </header>
-        
-        <main>
-            <section class="section">
-                <div class="section__header">
-                    <h2 class="section__title"><i class="fas fa-user-circle"></i> Characters</h2>
-                    <button class="button button--primary" id="addCharacterBtn">
-                        <i class="fas fa-user-plus"></i> Add Character
-                    </button>
-                </div>
-                <div id="characterList" class="card-grid"></div>
-            </section>
-            
-            <section class="section">
-                <div class="section__header">
-                    <h2 class="section__title"><i class="fas fa-database"></i> Datasets</h2>
-                    <button class="button button--primary" id="addDatasetBtn">
-                        <i class="fas fa-plus"></i> Add Dataset
-                    </button>
-                </div>
-                <div id="datasetList" class="card-grid"></div>
-            </section>
-
-            <section class="section">
-                <div class="section__header">
-                    <h2 class="section__title"><i class="fas fa-chart-bar"></i> Evaluation</h2>
-                </div>
-                <div class="eval-controls">
-                    <select id="evalCharacterSelect" class="form__input"></select>
-                    <select id="evalDatasetSelect" class="form__input"></select>
-                    <button id="evaluateBtn" class="button button--primary">
-                        <i class="fas fa-play"></i> Evaluate
-                    </button>
-                    <button id="clearEvaluationBtn" class="button button--primary">
-                        <i class="fas fa-trash"></i> Clear
-                    </button>
-                </div>
-                <div id="evaluationResults"></div>
-            </section>
-        </main>
-    </div>
-
-    <div class="panel" id="slidingPanel">
-        <button class="panel__close-btn" id="closePanelBtn">
-            <i class="fas fa-times"></i>
-        </button>
-        <h2 class="panel__title" id="panelTitle"></h2>
-        <form class="panel__form" id="panelForm"></form>
+    <div class="app-container">
+        {% include 'components/sidenav.html' %}
+        {% include 'components/main-content.html' %}
     </div>
 
-    <div class="overlay" id="overlay"></div>
-
     <script type="module" src="{{ url_for('static', filename='js/main.js') }}"></script>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/templates/login.html b/src/templates/login.html
index f67eccf..8d147e3 100644
--- a/src/templates/login.html
+++ b/src/templates/login.html
@@ -3,15 +3,21 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Login - Character Manager</title>
+    <title>Login - ProBack</title>
     <link rel="stylesheet" href="{{ url_for('static', filename='css/auth/login.css') }}">
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
 </head>
 <body>
+    <div class="background-shapes"></div>
     <div class="login-container">
         <div class="login-box">
-            <h1>Character Manager</h1>
-            <p>Please sign in to continue</p>
+            <div class="logo">
+                <img src="{{ url_for('static', filename='images/logo.png') }}" alt="Logo">
+            </div>
+            <h1>ProBack</h1>
+            <p class="subtitle">GenAI Evaluation done right</p>
             <button id="googleSignIn" class="google-btn">
+                <img src="{{ url_for('static', filename='images/google-icon.png') }}" alt="Google">
                 Sign in with Google
             </button>
         </div>