README uopdated

README.md

@@ -1,643 +1,394 @@
+
 # 🔍 AI Text Authentication Platform
-## Enterprise-Grade AI Content Authentication
+## Enterprise‑Grade AI Content Authentication
 
 ![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
 ![FastAPI](https://img.shields.io/badge/FastAPI-0.104+-green.svg)
-![Accuracy](https://img.shields.io/badge/accuracy-~90%2525+-success.svg)
+![Accuracy](https://img.shields.io/badge/accuracy-~90%25+-success.svg)
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Code Style](https://img.shields.io/badge/code%2520style-black-black.svg)
+![Code Style](https://img.shields.io/badge/code%20style-black-black.svg)
 
 ---
 
 ## 📋 Table of Contents
 
+- [Abstract](#-abstract)
 - [Overview](#-overview)
 - [Key Differentiators](#-key-differentiators)
 - [System Architecture](#-system-architecture)
+- [Workflow / Data Flow](#-workflow--data-flow)
 - [Detection Metrics & Mathematical Foundation](#-detection-metrics--mathematical-foundation)
 - [Ensemble Methodology](#-ensemble-methodology)
+- [Domain‑Aware Detection](#-domain-aware-detection)
+- [Performance & Cost Characteristics](#-performance--cost-characteristics)
 - [Project Structure](#-project-structure)
 - [API Endpoints](#-api-endpoints)
-- [Domain-Aware Detection](#-domain-aware-detection)
-- [Performance Characteristics](#-performance-characteristics)
 - [Installation & Setup](#-installation--setup)
-- [Security & Privacy](#-security--privacy)
-- [Accuracy & Validation](#-accuracy--validation)
+- [Model Management & First‑Run Behavior](#-model-management--first-run-behavior)
 - [Frontend Features](#-frontend-features)
+- [Accuracy, Validation & Continuous Improvement](#-accuracy-validation--continuous-improvement)
 - [Business Model & Market Analysis](#-business-model--market-analysis)
-- [Future Enhancements](#-future-enhancements)
-- [Support & Documentation](#-support--documentation)
+- [Research Impact & Future Scope](#-research-impact--future-scope)
+- [Infrastructure & Deployment](#-infrastructure--deployment)
+- [Security & Risk Mitigation](#-security--risk-mitigation)
+- [License & Acknowledgments](#-license--acknowledgments)
 
 ---
 
-## 🚀 Overview
-
-The **AI Text Authentication Platform** is a system designed to identify AI-generated content across multiple domains with exceptional accuracy. The platform addresses the growing challenge of content authenticity in education, publishing, hiring, and research sectors.
-
-### What Makes This Platform Unique?
-
-The system employs a **sophisticated ensemble of 6 complementary detection metrics** with **domain-aware calibration**, achieving **~90% accuracy** while maintaining computational efficiency, real-time performance, and complete explainability. Unlike traditional single-metric detectors, our platform analyzes text through multiple independent lenses to capture orthogonal signals that AI-generated content exhibits.
-
-### Core Capabilities
+## 📝 Abstract
 
-**Multi-Domain Analysis**
-- **Academic Domain**: Optimized for essays, research papers, and scholarly writing with specialized linguistic pattern recognition
-- **Technical Documentation**: Calibrated for medical papers, technical manuals, and documentation with high-precision thresholds
-- **Creative Writing**: Tuned for stories, narratives, and creative content with burstiness detection
-- **Social Media**: Adapted for informal writing, blogs, and conversational text with relaxed linguistic requirements
+**AI Text Authentication Platform** is a research‑oriented, production‑minded MVP that detects and attributes AI‑generated text across multiple domains using a multi‑metric, explainable ensemble approach. The platform is designed for reproducibility, extensibility, and real‑world deployment: model weights are auto‑fetched from Hugging Face on first run and cached for offline reuse.
 
-**Comprehensive Detection Pipeline**
-1. **Automatic Domain Classification**: Intelligent identification of content type to apply appropriate detection parameters
-2. **Multi-Metric Analysis**: Parallel execution of 6 independent metrics capturing different aspects of text generation
-3. **Ensemble Aggregation**: Confidence-calibrated weighted voting with uncertainty quantification
-4. **Model Attribution**: Identifies specific AI models (GPT-4, Claude, Gemini, LLaMA, etc.) with confidence scores
-5. **Explainable Results**: Sentence-level highlighting with detailed reasoning and evidence presentation
+This README is research‑grade (detailed math, methodology, and benchmarks) while being approachable for recruiters and technical reviewers.
 
-**Market-Ready Features**
-- **High Performance**: Analyzes 100-500 word texts in 1.2 seconds with parallel computation
-- **Scalable Architecture**: Auto-scaling infrastructure supporting batch processing and high-volume requests
-- **Multi-Format Support**: Handles PDF, DOCX, TXT, DOC, and MD files with automatic text extraction
-- **RESTful API**: Comprehensive API with authentication, rate limiting, and detailed documentation
-- **Real-Time Dashboard**: Interactive web interface with dual-panel design and live analysis
-- **Comprehensive Reporting**: Downloadable JSON and PDF reports with complete analysis breakdown
-
-### Problem Statement & Market Context
+---
 
-**Academic Integrity Crisis**
-- 60% of students regularly use AI tools for assignments
-- 89% of teachers report AI-written submissions
-- Traditional assessment methods becoming obsolete
+## 🚀 Overview
 
-**Hiring Quality Degradation**
-- AI-generated applications masking true candidate qualifications
-- Remote hiring amplifying verification challenges
+**Problem.** AI generation tools increasingly produce publishable text, creating integrity and verification challenges in education, hiring, publishing, and enterprise content systems.
 
-**Content Platform Spam**
-- AI-generated articles flooding publishing platforms
-- SEO manipulation through AI content farms
-- Trust erosion in digital content ecosystems
+**Solution.** A domain‑aware detector combining six orthogonal metrics (Perplexity, Entropy, Structural, Semantic, Linguistic, DetectGPT perturbation stability) into a confidence‑calibrated ensemble. Outputs are explainable with sentence‑level highlighting, attribution probabilities, and downloadable reports (JSON/PDF).
 
-**Market Opportunity**
-- **Total Addressable Market**: $20B with 42% YoY growth
-- **Education Sector**: $12B (45% growth rate)
-- **Enterprise Hiring**: $5B (30% growth rate)
-- **Content Publishing**: $3B (60% growth rate)
+**MVP Scope.** End‑to‑end FastAPI backend, lightweight HTML UI, modular metrics, Hugging Face model auto‑download, and a prototype ensemble classifier. Model weights are not committed to the repo; they are fetched at first run.
 
 ---
 
 ## 🎯 Key Differentiators
 
 | Feature | Description | Impact |
-|---------|-------------|--------|
-| 🎯 **Domain-Aware Detection** | Calibrated thresholds for Academic, Technical, Creative, and Social Media content | 15-20% accuracy improvement over generic detection |
-| 🔬 **6-Metric Ensemble** | Combines orthogonal signal capture methods for robust detection | only 2.4% false positive rate |
-| 💡 **Explainable Results** | Sentence-level highlighting with confidence scores and detailed reasoning | Enhanced trust and actionable insights for users |
-| 🚀 **High Performance** | Analyzes texts in 1.2-3.5 seconds with parallel computation | Real-time analysis capability for interactive use |
-| 🤖 **Model Attribution** | Identifies specific AI models (GPT-4, Claude, Gemini, LLaMA, etc.) | Forensic-level analysis for advanced use cases |
-| 🔄 **Continuous Learning** | Automated retraining pipeline with model versioning | Adaptation to new AI models and generation patterns |
+|---|---:|---|
+| **Domain‑Aware Detection** | Per‑domain thresholding and weight tuning (academic, technical, creative, social) | ↑15–20% accuracy vs generic detectors |
+| **6‑Metric Ensemble** | Orthogonal signals across statistical, syntactic and semantic dimensions | Low false positives (≈2–3%) |
+| **Explainability** | Sentence‑level scoring, highlights, and human‑readable reasoning | Trust & auditability |
+| **Model Attribution** | Likely model identification (GPT‑4, Claude, Gemini, LLaMA, etc.) | Forensic insights |
+| **Auto Model Fetch** | First‑run download from Hugging Face, local cache, offline fallback | Lightweight repo & reproducible runs |
+| **Extensible Design** | Plug‑in metrics, model registry, and retraining pipeline hooks | Easy research iteration |
 
 ---
 
 ## 🏗️ System Architecture
 
-### High-Level Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                         Frontend Layer                          │
-│  React Web App │ File Upload │ Real-Time Dashboard │ Reports   │
-└────────────────────────────────┬────────────────────────────────┘
-                                 │
-┌────────────────────────────────▼────────────────────────────────┐
-│                         API Gateway                              │
-│  FastAPI │ JWT Auth │ Rate Limiting │ Request Validation        │
-└────────────────────────────────┬────────────────────────────────┘
-                                 │
-┌────────────────────────────────▼────────────────────────────────┐
-│                      Detection Orchestrator                      │
-│  Domain Classification │ Preprocessing │ Metric Coordination    │
-└─────┬──────────┬──────────┬──────────┬──────────┬──────────────┘
-      │          │          │          │          │
-┌─────▼────┐ ┌──▼─────┐ ┌──▼─────┐ ┌──▼─────┐ ┌──▼─────┐ ┌──────────┐
-│Perplexity│ │Entropy │ │Struct. │ │Ling.   │ │Semantic│ │DetectGPT │
-│ Metric   │ │ Metric │ │ Metric │ │ Metric │ │ Metric │ │  Metric  │
-│  (25%)   │ │ (20%)  │ │ (15%)  │ │ (15%)  │ │ (15%)  │ │  (10%)   │
-└─────┬────┘ └──┬─────┘ └──┬─────┘ └──┬─────┘ └──┬─────┘ └──┬───────┘
-      │          │          │          │          │          │
-      └──────────┴──────────┴──────────┴──────────┴──────────┘
-                                 │
-┌────────────────────────────────▼────────────────────────────────┐
-│                      Ensemble Classifier                         │
-│  Confidence Calibration │ Weighted Aggregation │ Uncertainty    │
-└────────────────────────────────┬────────────────────────────────┘
-                                 │
-┌────────────────────────────────▼────────────────────────────────┐
-│                   Post-Processing & Reporting                    │
-│  Attribution │ Highlighting │ Reasoning │ Report Generation     │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-### Data Flow Pipeline
-
-```
-Input Text → Domain Classification → Preprocessing
-     ↓
-Parallel Metric Computation
-     ↓
-Ensemble Aggregation → Confidence Calibration
-     ↓
-Model Attribution → Sentence Highlighting
-     ↓
-Reasoning Generation → Report Creation
-     ↓
-API Response (JSON/PDF)
-```
+### Architecture (Dark‑themed Mermaid)
+
+```mermaid
+%%{init: {'theme': 'dark'}}%%
+flowchart LR
+    subgraph FE [Frontend Layer]
+        A[Web UI<br/>File Upload & Input]
+        B[Interactive Dashboard]
+    end
+
+    subgraph API [API & Gateway]
+        C[FastAPI<br/>Auth & Rate Limit]
+    end
+
+    subgraph ORCH [Detection Orchestrator]
+        D[Domain Classifier]
+        E[Preprocessor]
+        F[Metric Coordinator]
+    end
+
+    subgraph METRICS [Metrics Pool]
+        P1[Perplexity]
+        P2[Entropy]
+        P3[Structural]
+        P4[Linguistic]
+        P5[Semantic]
+        P6[DetectGPT]
+    end
+
+    G[Ensemble Classifier]
+    H[Postprocessing & Reporter]
+    I[Model Manager<br/>(HuggingFace Cache)]
+    J[Storage: Logs, Reports, Cache]
+
+    A --> C
+    B --> C
+    C --> ORCH
+    ORCH --> METRICS
+    METRICS --> G
+    G --> H
+    H --> C
+    I --> ORCH
+    C --> J
+```
+
+**Notes:** The orchestrator schedules parallel metric computation, handles timeouts, and coordinates with the model manager for model loading and caching.
 
 ---
 
-## 📊 Detection Metrics & Mathematical Foundation
-
-### 🎯 Metric Selection Rationale
-
-The 6-metric ensemble was carefully designed to capture **orthogonal signals** from different aspects of text generation. Each metric analyzes a distinct dimension of text, ensuring that the system cannot be easily fooled by sophisticated AI generation techniques.
-
-| Metric | Weight | Signal Type | Rationale |
-|--------|--------|-------------|-----------|
-| **Perplexity** | 25% | Statistical | Measures predictability to language models - captures how "expected" the text is |
-| **Entropy** | 20% | Information-theoretic | Captures token diversity and randomness - detects repetitive patterns |
-| **Structural** | 15% | Pattern-based | Analyzes sentence structure consistency - identifies uniform formatting |
-| **Semantic Analysis** | 15% | Coherence-based | Evaluates logical flow and consistency - detects semantic anomalies |
-| **Linguistic** | 15% | Grammar-based | Assesses syntactic complexity patterns - measures grammatical sophistication |
-| **DetectGPT** | 10% | Perturbation-based | Tests text stability under modifications - validates generation artifacts |
-
-### Three-Dimensional Text Analysis Framework
-
-Our 6-metric ensemble captures three fundamental dimensions of text that distinguish human from AI-generated content across all domains:
-
-#### Dimension 1: Statistical Predictability & Token Distribution
-**Metrics Involved**: Perplexity (25%), Entropy (20%)
-
-**What It Captures**:
-- **Perplexity**: Measures how surprised a language model is by the text. AI-generated text follows learned probability distributions closely, resulting in lower perplexity (15-30), while human writing exhibits creative unpredictability with higher perplexity (40-80).
-- **Entropy**: Quantifies token-level randomness and vocabulary diversity. AI models tend toward repetitive token selection patterns (2.8-3.8 bits/token), whereas humans use more varied vocabulary (4.2-5.5 bits/token).
-
-**Domain Manifestations**:
-- **Academic**: Human papers show higher entropy in technical terminology selection, varied sentence starters
-- **Technical**: AI documentation exhibits predictable term sequences; humans show domain expertise through unexpected connections
-- **Creative**: Human creativity produces higher entropy in word choice; AI follows genre conventions rigidly
-- **Social Media**: Humans use slang, abbreviations unpredictably; AI maintains consistent formality
-
-#### Dimension 2: Structural & Syntactic Patterns
-**Metrics Involved**: Structural (15%), Linguistic (15%)
-
-**What It Captures**:
-- **Structural**: Analyzes sentence length variance (burstiness), paragraph uniformity, and formatting consistency. AI generates overly uniform structures, while humans naturally vary their writing rhythm.
-- **Linguistic**: Evaluates POS tag diversity, parse tree depth, and grammatical sophistication. AI models produce predictable syntactic patterns, whereas humans exhibit more complex and varied grammatical structures.
-
-**Domain Manifestations**:
-- **Academic**: AI papers show uniform paragraph lengths; humans vary based on argument complexity
-- **Technical**: AI maintains consistent sentence structure in procedures; humans adjust complexity for concept difficulty
-- **Creative**: Humans use burstiness for dramatic effect (short sentences in action, longer in description); AI averages out
-- **Social Media**: Human posts vary wildly in length/structure; AI maintains unnatural consistency
-
-#### Dimension 3: Semantic Coherence & Content Stability
-**Metrics Involved**: Semantic Analysis (15%), DetectGPT (10%)
-
-**What It Captures**:
-- **Semantic Analysis**: Measures sentence-to-sentence coherence, n-gram repetition patterns, and contextual consistency. AI sometimes produces semantically coherent but contextually shallow connections.
-- **DetectGPT**: Tests text stability under perturbation. AI-generated text sits at probability peaks in the model's output space, making it more sensitive to small changes, while human text is more robust to minor modifications.
-
-**Domain Manifestations**:
-- **Academic**: AI arguments show surface-level coherence but lack deep logical progression; humans build cumulative reasoning
-- **Technical**: AI procedures are coherent but may miss implicit expert knowledge; humans include domain-specific nuances
-- **Creative**: AI narratives maintain consistency but lack subtle foreshadowing; humans plant intentional inconsistencies for plot
-- **Social Media**: AI maintains topic focus rigidly; humans naturally digress and return to main points
-
-### Cross-Dimensional Detection Power
-
-The ensemble's strength lies in capturing **multi-dimensional anomalies** simultaneously:
-
-**Example 1: Sophisticated GPT-4 Academic Essay**
-- Dimension 1 (Statistical): Low perplexity (22) + low entropy (3.2) → **AI signal**
-- Dimension 2 (Structural): High sentence uniformity (burstiness: 0.15) → **AI signal**  
-- Dimension 3 (Semantic): High coherence but low perturbation stability → **AI signal**
-- **Result**: High-confidence AI detection (92% probability)
-
-**Example 2: Human Technical Documentation**
-- Dimension 1 (Statistical): Moderate perplexity (35) + moderate entropy (4.0) → **Human signal**
-- Dimension 2 (Structural): Varied structure with intentional consistency in procedures → **Mixed signal**
-- Dimension 3 (Semantic): Deep coherence + high perturbation stability → **Human signal**
-- **Result**: High-confidence human detection (88% human probability)
-
-**Example 3: Human-Edited AI Content (Mixed)**
-- Dimension 1 (Statistical): Low perplexity core with high-entropy edits → **Mixed signal**
-- Dimension 2 (Structural): Sections of uniformity interrupted by varied structures → **Mixed signal**
-- Dimension 3 (Semantic): Stable AI sections + unstable human additions → **Mixed signal**
-- **Result**: Mixed content detection with section-level attribution
+## 🔁 Workflow / Data Flow
+
+```mermaid
+%%{init: {'theme': 'dark'}}%%
+sequenceDiagram
+    participant U as User (UI/API)
+    participant API as FastAPI
+    participant O as Orchestrator
+    participant M as Metrics Pool
+    participant E as Ensemble
+    participant R as Reporter
+
+    U->>API: Submit text / upload file
+    API->>O: Validate & enqueue job
+    O->>M: Preprocess & dispatch metrics (parallel)
+    M-->>O: Metric results (async)
+    O->>E: Aggregate & calibrate
+    E-->>O: Final verdict + uncertainty
+    O->>R: Generate highlights & report
+    R-->>API: Report ready (JSON/PDF)
+    API-->>U: Return analysis + download link
+```
 
 ---
 
-## 🔬 Detailed Mathematical Formulations
+## 🧮 Detection Metrics & Mathematical Foundation
 
-### 1. Perplexity Metric (25% Weight)
+This section provides the exact metric definitions implemented in `metrics/` and rationale for their selection. The ensemble combines these orthogonal signals to increase robustness against adversarial or edited AI content.
 
-**Mathematical Definition**:
-```python
-Perplexity = exp(-1/N * Σ(log P(w_i | w_{i-1}, ..., w_{i-k})))
-```
-
-**Where**:
-- `N` = number of tokens
-- `P(w_i | context)` = conditional probability from GPT-2 XL
-- `k` = context window size
+### Metric summary (weights are configurable per domain)
+- Perplexity — 25%
+- Entropy — 20%
+- Structural — 15%
+- Semantic — 15%
+- Linguistic — 15%
+- DetectGPT (perturbation stability) — 10%
 
-**AI Detection Logic**:
-- **AI text**: Lower perplexity (15-30) - more predictable to language models
-- **Human text**: Higher perplexity (40-80) - more creative and unpredictable
+### 1) Perplexity (25% weight)
 
-**Domain Calibration**:
-```python
-# Academic texts naturally have lower perplexity
-if domain == Domain.ACADEMIC:
-    perplexity_threshold *= 1.2
-elif domain == Domain.SOCIAL_MEDIA:
-    perplexity_threshold *= 0.8
-```
+**Definition**
+\(\displaystyle Perplexity = \exp\left(-\frac{1}{N}\sum_{i=1}^N \log P(w_i\mid context)\right)\)
 
-**Implementation**:
+**Implementation sketch**
 ```python
-def calculate_perplexity(text, model):
+def calculate_perplexity(text, model, k=512):
     tokens = tokenize(text)
     log_probs = []
-    
     for i in range(len(tokens)):
         context = tokens[max(0, i-k):i]
         prob = model.get_probability(tokens[i], context)
         log_probs.append(math.log(prob))
-    
-    return math.exp(-sum(log_probs) / len(tokens))
+    return math.exp(-sum(log_probs)/len(tokens))
 ```
 
----
-
-### 2. Entropy Metric (20% Weight)
-
-**Shannon Entropy**:
+**Domain calibration example**
 ```python
-H(X) = -Σ P(x_i) * log2(P(x_i))
+if domain == Domain.ACADEMIC:
+    perplexity_threshold *= 1.2
+elif domain == Domain.SOCIAL_MEDIA:
+    perplexity_threshold *= 0.8
 ```
 
-**Token-Level Analysis**:
+### 2) Entropy (20% weight)
+
+**Shannon entropy (token level)**
+\(\;H(X) = -\sum_{i} p(x_i)\log_2 p(x_i)\)
+
+**Implementation sketch**
 ```python
+from collections import Counter
 def calculate_text_entropy(text):
     tokens = text.split()
     token_freq = Counter(tokens)
-    total_tokens = len(tokens)
-    
-    entropy = 0
-    for token, freq in token_freq.items():
-        probability = freq / total_tokens
-        entropy -= probability * math.log2(probability)
-    
+    total = len(tokens)
+    entropy = -sum((f/total) * math.log2(f/total) for f in token_freq.values())
     return entropy
 ```
 
-**Detection Patterns**:
-- **AI text**: Lower entropy (2.8-3.8 bits/token) - repetitive patterns
-- **Human text**: Higher entropy (4.2-5.5 bits/token) - diverse vocabulary
-
-**Advanced Features**:
-- N-gram entropy analysis (bigrams, trigrams)
-- Contextual entropy using sliding windows
-- Conditional entropy between adjacent sentences
-
----
-
-### 3. Structural Metric (15% Weight)
-
-**Burstiness Score**:
-```python
-Burstiness = (σ - μ) / (σ + μ)
-```
-
-**Where**:
-- `σ` = standard deviation of sentence lengths
-- `μ` = mean sentence length
+### 3) Structural Metric (15% weight)
 
-**Length Uniformity**:
-```python
-Uniformity = 1 - (std_dev / mean_length)
-```
+**Burstiness**
+\(\displaystyle Burstiness=\frac{\sigma-\mu}{\sigma+\mu}\) where \(\mu\)=mean sentence length, \(\sigma\)=std dev
 
-**AI Patterns Detected**:
-- Overly consistent sentence lengths (low burstiness)
-- Predictable paragraph structures
-- Limited structural variation
-- Uniform punctuation usage
+**Uniformity**
+\(\displaystyle Uniformity = 1 - \frac{\sigma}{\mu}\)
 
-**Implementation**:
+**Sketch**
 ```python
 def calculate_burstiness(text):
     sentences = split_sentences(text)
     lengths = [len(s.split()) for s in sentences]
-    
     mean_len = np.mean(lengths)
     std_len = np.std(lengths)
-    
     burstiness = (std_len - mean_len) / (std_len + mean_len)
-    uniformity = 1 - (std_len / mean_len if mean_len > 0 else 0)
-    
-    return {
-        'burstiness': burstiness,
-        'uniformity': uniformity,
-        'mean_length': mean_len,
-        'std_length': std_len
-    }
-```
-
----
-
-### 4. Semantic Analysis Metric (15% Weight)
-
-**Coherence Scoring**:
-```python
-Coherence = 1/n * Σ cosine_similarity(sentence_i, sentence_{i+1})
+    uniformity = 1 - (std_len/mean_len if mean_len > 0 else 0)
+    return {'burstiness': burstiness, 'uniformity': uniformity}
 ```
 
-**Repetition Detection**:
-```python
-Repetition_Score = count_ngram_repeats(text, n=3) / total_ngrams
-```
+### 4) Semantic Analysis (15% weight)
 
-**Advanced Analysis**:
-- Sentence embedding similarity using BERT/Sentence-BERT
-- Topic consistency across paragraphs
-- Logical flow assessment
-- Redundancy pattern detection
+**Coherence (sentence embedding cosine similarity)**
+\(\displaystyle Coherence=\frac{1}{n}\sum_{i=1}^{n-1} \cos(e_i, e_{i+1})\)
 
-**Implementation**:
+**Sketch**
 ```python
-def calculate_semantic_coherence(text, model):
+def calculate_semantic_coherence(text, embed_model):
     sentences = split_sentences(text)
-    embeddings = [model.encode(s) for s in sentences]
-    
-    coherence_scores = []
-    for i in range(len(embeddings) - 1):
-        similarity = cosine_similarity(embeddings[i], embeddings[i+1])
-        coherence_scores.append(similarity)
-    
-    return {
-        'mean_coherence': np.mean(coherence_scores),
-        'coherence_variance': np.var(coherence_scores),
-        'coherence_scores': coherence_scores
-    }
+    embeddings = [embed_model.encode(s) for s in sentences]
+    sims = [cosine_similarity(embeddings[i], embeddings[i+1]) for i in range(len(embeddings)-1)]
+    return {'mean_coherence': np.mean(sims), 'coherence_variance': np.var(sims)}
 ```
 
----
-
-### 5. Linguistic Metric (15% Weight)
-
-**POS Tag Diversity**:
-```python
-POS_Diversity = unique_POS_tags / total_tokens
-```
-
-**Syntactic Complexity**:
-```python
-Complexity = average_parse_tree_depth(sentences)
-```
+### 5) Linguistic Metric (15% weight)
 
-**Features Analyzed**:
-- Part-of-speech tag distribution
-- Dependency parse tree depth and structure
-- Syntactic variety across sentences
-- Grammatical sophistication indicators
+**POS diversity, parse tree depth, syntactic complexity**
 
-**Implementation**:
 ```python
 def calculate_linguistic_features(text, nlp_model):
     doc = nlp_model(text)
-    
-    # POS diversity
     pos_tags = [token.pos_ for token in doc]
-    pos_diversity = len(set(pos_tags)) / len(pos_tags)
-    
-    # Syntactic complexity
-    depths = []
-    for sent in doc.sents:
-        depth = max(get_tree_depth(token) for token in sent)
-        depths.append(depth)
-    
-    return {
-        'pos_diversity': pos_diversity,
-        'mean_tree_depth': np.mean(depths),
-        'complexity_variance': np.var(depths)
-    }
+    pos_diversity = len(set(pos_tags))/len(pos_tags)
+    depths = [max(get_tree_depth(token) for token in sent) for sent in doc.sents]
+    return {'pos_diversity': pos_diversity, 'mean_tree_depth': np.mean(depths)}
 ```
 
----
+### 6) DetectGPT (10% weight)
 
-### 6. DetectGPT Metric (10% Weight)
+**Stability under perturbation** (curvature principle)
+\(\displaystyle Stability = \frac{1}{n}\sum_{j} \left|\log P(x) - \log P(x_{perturbed}^j)\right|\)
 
-**Curvature Principle**:
-```python
-Stability_Score = 1/n * Σ |log P(x) - log P(x_perturbed)|
-```
-
-Where `x_perturbed` are minor modifications of the original text.
-
-**Perturbation Strategy**:
-- Random word substitutions with synonyms
-- Minor grammatical alterations
-- Punctuation modifications
-- Word order variations in non-critical positions
-
-**Theory**:
-AI-generated text sits at local maxima in the model's probability distribution. Small perturbations cause larger probability drops for AI text than for human text.
-
-**Implementation**:
 ```python
 def detect_gpt_score(text, model, num_perturbations=20):
-    original_prob = model.get_log_probability(text)
-    
-    perturbation_diffs = []
+    original = model.get_log_probability(text)
+    diffs = []
     for _ in range(num_perturbations):
         perturbed = generate_perturbation(text)
-        perturbed_prob = model.get_log_probability(perturbed)
-        diff = abs(original_prob - perturbed_prob)
-        perturbation_diffs.append(diff)
-    
-    stability_score = np.mean(perturbation_diffs)
-    return stability_score
+        diffs.append(abs(original - model.get_log_probability(perturbed)))
+    return np.mean(diffs)
 ```
 
 ---
 
 ## 🏛️ Ensemble Methodology
 
-### Confidence-Calibrated Aggregation
-
-The ensemble uses a sophisticated weighting system that considers both static domain weights and dynamic confidence calibration:
+### Confidence‑Calibrated Aggregation (high level)
+- Start with domain base weights (e.g., `DOMAIN_WEIGHTS` in `config/threshold_config.py`)
+- Adjust weights per metric with a sigmoid confidence scaling function
+- Normalize and compute weighted aggregate
+- Quantify uncertainty using variance, confidence means, and decision distance from 0.5
 
 ```python
 def ensemble_aggregation(metric_results, domain):
-    # Base weights from domain configuration
-    base_weights = get_domain_weights(domain)
-    
-    # Confidence-based adjustment
-    confidence_weights = {}
-    for metric, result in metric_results.items():
-        confidence_factor = sigmoid_confidence_adjustment(result.confidence)
-        confidence_weights[metric] = base_weights[metric] * confidence_factor
-    
-    # Normalize and aggregate
-    total_weight = sum(confidence_weights.values())
-    final_weights = {k: v/total_weight for k, v in confidence_weights.items()}
-    
+    base = get_domain_weights(domain)
+    adj = {m: base[m] * sigmoid_confidence(r.confidence) for m, r in metric_results.items()}
+    total = sum(adj.values())
+    final_weights = {k: v/total for k, v in adj.items()}
     return weighted_aggregate(metric_results, final_weights)
 ```
 
 ### Uncertainty Quantification
-
 ```python
 def calculate_uncertainty(metric_results, ensemble_result):
-    # Variance in predictions
-    variance_uncertainty = np.var([r.ai_probability for r in metric_results.values()])
-    
-    # Confidence uncertainty
-    confidence_uncertainty = 1 - np.mean([r.confidence for r in metric_results.values()])
-    
-    # Decision uncertainty (distance from 0.5)
-    decision_uncertainty = 1 - 2 * abs(ensemble_result.ai_probability - 0.5)
-    
-    return (variance_uncertainty * 0.4 + 
-            confidence_uncertainty * 0.3 + 
-            decision_uncertainty * 0.3)
+    var_uncert = np.var([r.ai_probability for r in metric_results.values()])
+    conf_uncert = 1 - np.mean([r.confidence for r in metric_results.values()])
+    decision_uncert = 1 - 2*abs(ensemble_result.ai_probability - 0.5)
+    return var_uncert*0.4 + conf_uncert*0.3 + decision_uncert*0.3
 ```
 
-### Domain-Specific Weight Adjustments
+---
+
+## 🧭 Domain‑Aware Detection
+
+Domain weights and thresholds are configurable. Example weights (in `config/threshold_config.py`):
 
 ```python
 DOMAIN_WEIGHTS = {
-    Domain.ACADEMIC: {
-        'perplexity': 0.22,
-        'entropy': 0.18,
-        'structural': 0.15,
-        'linguistic': 0.20,  # Increased for academic rigor
-        'semantic': 0.15,
-        'detect_gpt': 0.10
-    },
-    Domain.TECHNICAL: {
-        'perplexity': 0.20,
-        'entropy': 0.18,
-        'structural': 0.12,
-        'linguistic': 0.18,
-        'semantic': 0.22,  # Increased for logical consistency
-        'detect_gpt': 0.10
-    },
-    Domain.CREATIVE: {
-        'perplexity': 0.25,
-        'entropy': 0.25,  # Increased for vocabulary diversity
-        'structural': 0.20,  # Increased for burstiness
-        'linguistic': 0.12,
-        'semantic': 0.10,
-        'detect_gpt': 0.08
-    },
-    Domain.SOCIAL_MEDIA: {
-        'perplexity': 0.30,  # Highest weight for statistical patterns
-        'entropy': 0.22,
-        'structural': 0.15,
-        'linguistic': 0.10,  # Relaxed for informal writing
-        'semantic': 0.13,
-        'detect_gpt': 0.10
-    }
+  'academic': {'perplexity':0.22,'entropy':0.18,'structural':0.15,'linguistic':0.20,'semantic':0.15,'detect_gpt':0.10},
+  'technical': {'perplexity':0.20,'entropy':0.18,'structural':0.12,'linguistic':0.18,'semantic':0.22,'detect_gpt':0.10},
+  'creative': {'perplexity':0.25,'entropy':0.25,'structural':0.20,'linguistic':0.12,'semantic':0.10,'detect_gpt':0.08},
+  'social_media': {'perplexity':0.30,'entropy':0.22,'structural':0.15,'linguistic':0.10,'semantic':0.13,'detect_gpt':0.10}
 }
 ```
 
+### Domain Calibration Strategy (brief)
+- **Academic**: increase linguistic weight, raise perplexity multiplier
+- **Technical**: prioritize semantic coherence, maximize AI threshold to reduce false positives
+- **Creative**: boost entropy & structural weights for burstiness detection
+- **Social Media**: prioritize perplexity and relax linguistic demands
+
+---
+
+## ⚡ Performance & Cost Characteristics
+
+### Processing Times & Resource Estimates
+
+| Text Length | Typical Time | vCPU | RAM |
+|---:|---:|---:|---:|
+| Short (100–500 words) | 1.2 s | 0.8 vCPU | 512 MB |
+| Medium (500–2000 words) | 3.5 s | 1.2 vCPU | 1 GB |
+| Long (2000+ words) | 7.8 s | 2.0 vCPU | 2 GB |
+
+**Optimizations implemented**
+- Parallel metric computation (thread/process pools)
+- Conditional execution & early exit on high confidence
+- Model caching & quantization support for memory efficiency
+
+### Cost Estimate (example)
+| Scenario | Time | Cost per analysis | Monthly cost (1k analyses) |
+|---|---:|---:|---:|
+| Short | 1.2 s | $0.0008 | $0.80 |
+| Medium | 3.5 s | $0.0025 | $2.50 |
+| Long | 7.8 s | $0.0058 | $5.80 |
+
 ---
 
-## 📁 Project Structure
+## 📁 Project Structure (as in repository)
 
 ```text
 text_auth/
 ├── config/
-│   ├── __init__.py
-│   ├── model_config.py           # AI-ML model configurations
-│   ├── settings.py               # Application settings
-│   └── threshold_config.py       # Domain-aware thresholds
-│
+│   ├── model_config.py
+│   ├── settings.py
+│   └── threshold_config.py
 ├── data/
-│   ├── reports/                  # Generated analysis reports
-│   └── uploads/                  # Temporary file uploads
-│
+│   ├── reports/
+│   └── uploads/
 ├── detector/
-│   ├── __init__.py
-│   ├── attribution.py            # AI model attribution
-│   ├── ensemble.py               # Ensemble classifier
-│   ├── highlighter.py            # Text highlighting
-│   └── orchestrator.py           # Main detection pipeline
-│
-├── logs/                         # Application logs
-│
+│   ├── attribution.py
+│   ├── ensemble.py
+│   ├── highlighter.py
+│   └── orchestrator.py
 ├── metrics/
-│   ├── __init__.py
-│   ├── base_metric.py            # Base metric class
-│   ├── detect_gpt.py             # DetectGPT implementation
-│   ├── entropy.py                # Entropy analysis
-│   ├── linguistic.py             # Linguistic analysis
-│   ├── perplexity.py             # Perplexity analysis
-│   ├── semantic_analysis.py      # Semantic coherence
-│   └── structural.py             # Structural patterns
-│
+│   ├── base_metric.py
+│   ├── detect_gpt.py
+│   ├── entropy.py
+│   ├── linguistic.py
+│   ├── perplexity.py
+│   ├── semantic_analysis.py
+│   └── structural.py
 ├── models/
-│   ├── __init__.py
-│   ├── model_manager.py          # Model lifecycle management
-│   └── model_registry.py         # Model version registry
-│
+│   ├── model_manager.py
+│   └── model_registry.py
 ├── processors/
-│   ├── __init__.py
-│   ├── document_extractor.py     # File format extraction
-│   ├── domain_classifier.py      # Domain classification
-│   ├── language_detector.py      # Language detection
-│   └── text_processor.py         # Text preprocessing
-│
+│   ├── document_extractor.py
+│   ├── domain_classifier.py
+│   ├── language_detector.py
+│   └── text_processor.py
 ├── reporter/
-│   ├── __init__.py
-│   ├── reasoning_generator.py    # Explanation generation
-│   └── report_generator.py       # JSON/PDF report generation
-│
+│   ├── reasoning_generator.py
+│   └── report_generator.py
 ├── ui/
-│   ├── __init__.py
-│   └── static/
-│       └── index.html            # Web interface
-│
+│   └── static/index.html
 ├── utils/
-│   ├── __init__.py
-│   └── logger.py                 # Centralized logging
-│
-├── example.py                    # Usage examples
-├── README.md                     # Project README
-├── requirements.txt              # Python dependencies
-├── run.sh                        # Application launcher
-└── text_auth_app.py              # FastAPI application entry
+│   └── logger.py
+├── example.py
+├── requirements.txt
+├── run.sh
+└── text_auth_app.py
 ```
 
 ---
 
-## 🌐 API Endpoints
-
-### Core Analysis Endpoints
+## 🌐 API Endpoints (Research‑grade spec)
 
-#### 1. Text Analysis
-**POST** `/api/analyze`
+### `/api/analyze` — Text Analysis (POST)
+Analyze raw text. Returns ensemble result, per‑metric scores, attribution, highlights, and reasoning.
 
-Analyze pasted text for AI generation.
-
-**Request**:
+**Request (JSON)**
 ```json
 {
-  "text": "The text to analyze...",
-  "domain": "academic|technical_doc|creative|social_media",
+  "text":"...",
+  "domain":"academic|technical_doc|creative|social_media",
   "enable_attribution": true,
   "enable_highlighting": true,
   "use_sentence_level": true,
@@ -645,666 +396,210 @@ Analyze pasted text for AI generation.
 }
 ```
 
-**Response**:
+**Response (JSON)** — abbreviated
 ```json
 {
-  "status": "success",
-  "analysis_id": "analysis_1701234567890",
-  "detection_result": {
-    "ensemble_result": {
-      "final_verdict": "AI-Generated",
-      "ai_probability": 0.8943,
-      "human_probability": 0.0957,
-      "mixed_probability": 0.0100,
-      "overall_confidence": 0.8721,
-      "uncertainty_score": 0.2345,
-      "consensus_level": 0.8123
-    },
-    "metric_results": {
-      "structural": {
-        "ai_probability": 0.85,
-        "confidence": 0.78,
-        "burstiness": 0.15,
-        "uniformity": 0.82
-      },
-      "perplexity": {
-        "ai_probability": 0.92,
-        "confidence": 0.89,
-        "score": 22.5
-      },
-      "entropy": {
-        "ai_probability": 0.88,
-        "confidence": 0.85,
-        "score": 3.2
-      },
-      "linguistic": {
-        "ai_probability": 0.87,
-        "confidence": 0.79,
-        "pos_diversity": 0.65
-      },
-      "semantic": {
-        "ai_probability": 0.89,
-        "confidence": 0.81,
-        "coherence": 0.78
-      },
-      "detect_gpt": {
-        "ai_probability": 0.84,
-        "confidence": 0.76,
-        "stability_score": 0.25
-      }
-    }
-  },
-  "attribution": {
-    "predicted_model": "gpt-4",
-    "confidence": 0.7632,
-    "model_probabilities": {
-      "gpt-4": 0.76,
-      "claude-3-opus": 0.21,
-      "gemini-pro": 0.03
-    }
+  "status":"success",
+  "analysis_id":"analysis_170...",
+  "detection_result":{
+    "ensemble_result":{ "final_verdict":"AI-Generated", "ai_probability":0.89, "uncertainty_score":0.23 },
+    "metric_results":{ "...": { "ai_probability":0.92, "confidence":0.89 } }
   },
-  "highlighted_html": "<div class='highlighted-text'>...</div>",
-  "reasoning": {
-    "summary": "Analysis indicates with high confidence that this text is AI-generated...",
-    "key_indicators": [
-      "Low perplexity (22.5) suggests high predictability to language models",
-      "Uniform sentence structure (burstiness: 0.15) indicates AI generation",
-      "Low entropy (3.2 bits/token) reveals repetitive token patterns"
-    ],
-    "confidence_explanation": "High confidence due to strong metric agreement (consensus: 81.2%)"
-  }
-}
-```
-
----
-
-#### 2. File Analysis
-**POST** `/api/analyze/file`
-
-Analyze uploaded documents (PDF, DOCX, TXT, DOC, MD).
-
-**Features**:
-- Automatic text extraction from multiple formats
-- Domain classification
-- File size validation (10MB limit)
-- Multi-page PDF support
-
-**Request** (multipart/form-data):
-```
-file: <binary file data>
-domain: "academic" (optional)
-enable_attribution: true (optional)
-```
-
-**Response**: Same structure as text analysis endpoint
-
----
-
-#### 3. Report Generation
-**POST** `/api/report/generate`
-
-Generate downloadable reports in JSON/PDF formats.
-
-**Request**:
-```json
-{
-  "analysis_id": "analysis_1701234567890",
-  "format": "json|pdf",
-  "include_highlights": true,
-  "include_metrics_breakdown": true
-}
-```
-
-**Supported Formats**:
-- `json`: Complete structured data
-- `pdf`: Printable professional reports
-
----
-
-### Utility Endpoints
-
-#### 4. Health Check
-**GET** `/health`
-
-```json
-{
-  "status": "healthy",
-  "version": "2.0.0",
-  "uptime": 12345.67,
-  "models_loaded": {
-    "orchestrator": true,
-    "attributor": true,
-    "highlighter": true
-  }
+  "attribution":{ "predicted_model":"gpt-4", "confidence":0.76 },
+  "highlighted_html":"<div>...</div>",
+  "reasoning":{ "summary":"...", "key_indicators":[ "...", "..."] }
 }
 ```
 
----
-
-#### 5. Domain Information
-**GET** `/api/domains`
+### `/api/analyze/file` — File Analysis (POST, multipart/form-data)
+Supports PDF, DOCX, TXT, DOC, MD. File size limit default: 10MB. Returns same structure as text analyze endpoint.
 
-Returns supported content domains with descriptions.
+### `/api/report/generate` — Report Generation (POST)
+Generate downloadable JSON or PDF reports for a given analysis id.
 
-```json
-{
-  "domains": [
-    {
-      "id": "academic",
-      "name": "Academic Writing",
-      "description": "Essays, research papers, scholarly articles",
-      "ai_threshold": 0.88,
-      "human_threshold": 0.65
-    },
-    {
-      "id": "technical_doc",
-      "name": "Technical Documentation",
-      "description": "Technical manuals, medical papers, research documentation",
-      "ai_threshold": 0.92,
-      "human_threshold": 0.72
-    },
-    {
-      "id": "creative",
-      "name": "Creative Writing",
-      "description": "Stories, narratives, creative content",
-      "ai_threshold": 0.78,
-      "human_threshold": 0.55
-    },
-    {
-      "id": "social_media",
-      "name": "Social Media & Casual",
-      "description": "Blogs, social posts, informal writing",
-      "ai_threshold": 0.80,
-      "human_threshold": 0.50
-    }
-  ]
-}
-```
+### Utility endpoints
+- `GET /health` — health status, models loaded, uptime
+- `GET /api/domains` — supported domains and thresholds
+- `GET /api/models` — detectable model list
 
 ---
 
-#### 6. AI Models
-**GET** `/api/models`
-
-Returns detectable AI models for attribution.
-
-```json
-{
-  "models": [
-    {"id": "gpt-4", "name": "GPT-4", "provider": "OpenAI"},
-    {"id": "gpt-3.5-turbo", "name": "GPT-3.5 Turbo", "provider": "OpenAI"},
-    {"id": "claude-3-opus", "name": "Claude 3 Opus", "provider": "Anthropic"},
-    {"id": "claude-3-sonnet", "name": "Claude 3 Sonnet", "provider": "Anthropic"},
-    {"id": "gemini-pro", "name": "Gemini Pro", "provider": "Google"},
-    {"id": "llama-2-70b", "name": "LLaMA 2 70B", "provider": "Meta"},
-    {"id": "mixtral-8x7b", "name": "Mixtral 8x7B", "provider": "Mistral AI"}
-  ]
-}
-```
-
----
-
-## 🎯 Domain-Aware Detection
-
-### Domain-Specific Thresholds
-
-| Domain | AI Threshold | Human Threshold | Key Adjustments |
-|--------|--------------|-----------------|-----------------|
-| **Academic** | > 0.88 | < 0.65 | Higher linguistic weight, reduced perplexity sensitivity |
-| **Technical/Medical** | > 0.92 | < 0.72 | Much higher thresholds, focus on semantic patterns |
-| **Creative Writing** | > 0.78 | < 0.55 | Balanced weights, emphasis on burstiness detection |
-| **Social Media** | > 0.80 | < 0.50 | Higher statistical weight, relaxed linguistic requirements |
-
-### Performance by Domain
-
-| Domain | Precision | Recall | F1-Score | False Positive Rate |
-|--------|-----------|--------|----------|---------------------|
-| **Academic Papers** | 96.2% | 93.8% | 95.0% | 1.8% |
-| **Student Essays** | 94.5% | 92.1% | 93.3% | 2.5% |
-| **Technical Documentation** | 92.8% | 90.5% | 91.6% | 3.1% |
-| **Mixed Human-AI Content** | 88.7% | 85.3% | 87.0% | 4.2% |
-
-### Domain Calibration Strategy
-
-**Academic Domain**
-- **Use Cases**: Essays, research papers, assignments
-- **Adjustments**: 
-  - Increased linguistic metric weight (20% vs 15% baseline)
-  - Higher perplexity threshold multiplier (1.2x)
-  - Stricter structural uniformity detection
-- **Rationale**: Academic writing naturally has lower perplexity due to formal language, requiring calibrated thresholds
-
-**Technical/Medical Domain**
-- **Use Cases**: Research papers, documentation, technical reports
-- **Adjustments**:
-  - Highest AI threshold (0.92) to minimize false positives
-  - Increased semantic analysis weight (22% vs 15%)
-  - Reduced linguistic weight for domain-specific terminology
-- **Rationale**: Technical content has specialized vocabulary that may appear "unusual" to general language models
-
-**Creative Writing Domain**
-- **Use Cases**: Stories, creative essays, narratives, personal writing
-- **Adjustments**:
-  - Highest entropy weight (25% vs 20%) for vocabulary diversity
-  - Increased structural weight (20% vs 15%) for burstiness detection
-  - Lower AI threshold (0.78) to catch creative AI content
-- **Rationale**: Human creativity exhibits high burstiness and vocabulary diversity
-
-**Social Media Domain**
-- **Use Cases**: Blogs, social posts, informal writing, casual content
-- **Adjustments**:
-  - Highest perplexity weight (30% vs 25%) for statistical patterns
-  - Relaxed linguistic requirements (10% vs 15%)
-  - Lower perplexity threshold multiplier (0.8x)
-- **Rationale**: Informal writing naturally has grammatical flexibility and slang usage
-
----
-
-## ⚡ Performance Characteristics
-
-### Processing Times
-
-| Text Length | Processing Time | CPU Usage | Memory Usage |
-|-------------|----------------|-----------|--------------|
-| **Short** (100-500 words) | 1.2 seconds | 0.8 vCPU | 512 MB |
-| **Medium** (500-2000 words) | 3.5 seconds | 1.2 vCPU | 1 GB |
-| **Long** (2000+ words) | 7.8 seconds | 2.0 vCPU | 2 GB |
-
-### Computational Optimization
-
-**Parallel Metric Computation**
-- Independent metrics run concurrently using thread pools
-- 3-4x speedup compared to sequential execution
-- Efficient resource utilization with async/await patterns
-
-**Conditional Execution**
-- Expensive metrics (DetectGPT) can be skipped for faster analysis
-- Adaptive threshold early-exit when high confidence is achieved
-- Progressive analysis with real-time confidence updates
-
-**Model Caching**
-- Pre-trained models loaded once at startup
-- Shared model instances across requests
-- Memory-efficient model storage with quantization
-
-**Memory Management**
-- Efficient text processing with streaming where possible
-- Automatic garbage collection of analysis artifacts
-- Bounded memory usage with configurable limits
-
-### Cost Analysis
-
-| Text Length | Processing Time | Cost per Analysis | Monthly Cost (1000 analyses) |
-|-------------|----------------|-------------------|------------------------------|
-| Short (100-500 words) | 1.2 sec | $0.0008 | $0.80 |
-| Medium (500-2000 words) | 3.5 sec | $0.0025 | $2.50 |
-| Long (2000+ words) | 7.8 sec | $0.0058 | $5.80 |
-| Batch (100 documents) | 45 sec | $0.42 | N/A |
-
----
-
-## 🔧 Installation & Setup
+## ⚙️ Installation & Setup
 
 ### Prerequisites
+- Python 3.8+
+- 4GB RAM (8GB recommended)
+- Disk: 2GB (models & deps)
+- OS: Linux/macOS/Windows (WSL supported)
 
-- **Python**: 3.8 or higher
-- **RAM**: 4GB minimum, 8GB recommended
-- **Disk Space**: 2GB for models and dependencies
-- **OS**: Linux, macOS, or Windows with WSL
-
-### Quick Start
-
+### Quickstart
 ```bash
-# Clone repository
-git clone https://github.com/your-org/ai-text-detector
-cd ai-text-detector
-
-# Create virtual environment
+git clone https://github.com/satyaki-mitra/text_authentication.git
+cd text_authentication
 python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-
-# Install dependencies
+source venv/bin/activate
 pip install -r requirements.txt
-
-# Start the application
-./run.sh
-# Or: python text_auth_app.py
+# Copy .env.example -> .env and set HF_TOKEN if using private models
+python text_auth_app.py
+# or: ./run.sh
 ```
 
-The application will be available at:
-- **Web Interface**: http://localhost:8000
-- **API Documentation**: http://localhost:8000/api/docs
-- **Interactive API**: http://localhost:8000/api/redoc
+**Dev tips**
+- Use `DEBUG=True` in `config/settings.py` for verbose logs
+- For containerized runs, see `Dockerfile` template (example included in repo suggestions)
 
-### Configuration
+---
 
-Edit `config/settings.py` to customize:
+## 🧠 Model Management & First‑Run Behavior
 
+- The application **automatically downloads** required model weights from Hugging Face on the first run and caches them to the local HF cache (or a custom path specified in `config/model_config.py`).
+- Model IDs and revisions are maintained in `models/model_registry.py` and referenced by `models/model_manager.py`.
+- **Best practices implemented**:
+  - Pin model revisions (e.g., `repo_id@v1.2.0`)
+  - Resumeable downloads using `huggingface_hub.snapshot_download`
+  - Optional `OFFLINE_MODE` to load local model paths
+  - Optional integrity checks (SHA256) after download
+  - Support for private HF repos using `HF_TOKEN` env var
+
+**Example snippet**
 ```python
-# Application Settings
-APP_NAME = "AI Text Detector"
-VERSION = "2.0.0"
-DEBUG = False
-
-# Server Configuration
-HOST = "0.0.0.0"
-PORT = 8000
-WORKERS = 4
-
-# Detection Settings
-DEFAULT_DOMAIN = "academic"
-ENABLE_ATTRIBUTION = True
-ENABLE_HIGHLIGHTING = True
-MAX_TEXT_LENGTH = 50000
-
-# File Upload Settings
-MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
-ALLOWED_EXTENSIONS = [".pdf", ".docx", ".txt", ".doc", ".md"]
-
-# Performance Settings
-METRIC_TIMEOUT = 30  # seconds
-ENABLE_PARALLEL_METRICS = True
-CACHE_MODELS = True
+from huggingface_hub import snapshot_download
+snapshot_download(repo_id="satyaki-mitra/text-detector-v1", local_dir="./models/text-detector-v1")
 ```
+
 ---
 
-## 📈 Accuracy & Validation
+## 🎨 Frontend Features (UI)
 
-### Benchmark Results
+- Dual‑panel responsive web UI (left: input / upload; right: live analysis)
+- Sentence‑level color highlights with tooltips and per‑metric breakdown
+- Progressive analysis updates (metric-level streaming)
+- Theme: light/dark toggle (UI respects user preference)
+- Export: JSON and PDF report download
+- Interactive elements: click to expand sentence reasoning, copy text snippets, download raw metrics
 
-The system has been validated on diverse datasets spanning multiple domains and AI models:
+---
 
-| Test Scenario | Samples | Accuracy | Precision | Recall |
-|---------------|---------|----------|-----------|--------|
-| **GPT-4 Generated Text** | 5,000 | 95.8% | 96.2% | 95.3% |
-| **Claude-3 Generated** | 3,000 | 94.2% | 94.8% | 93.5% |
-| **Gemini Pro Generated** | 2,500 | 93.6% | 94.1% | 93.0% |
-| **LLaMA 2 Generated** | 2,000 | 92.8% | 93.3% | 92.2% |
-| **Human Academic Writing** | 10,000 | 96.1% | 95.7% | 96.4% |
-| **Human Creative Writing** | 5,000 | 94.8% | 94.3% | 95.2% |
-| **Mixed Content** | 2,000 | 88.7% | 89.2% | 88.1% |
-| **Overall Weighted** | 29,500 | **94.3%** | **94.6%** | **94.1%** |
+## 📈 Accuracy, Validation & Continuous Improvement
 
-### Confusion Matrix Analysis
+### Benchmark Summary (reported across internal test sets)
+| Scenario | Samples | Accuracy | Precision | Recall |
+|---|---:|---:|---:|---:|
+| GPT‑4 | 5,000 | 95.8% | 96.2% | 95.3% |
+| Claude‑3 | 3,000 | 94.2% | 94.8% | 93.5% |
+| Gemini Pro | 2,500 | 93.6% | 94.1% | 93.0% |
+| LLaMA 2 | 2,000 | 92.8% | 93.3% | 92.2% |
+| Human Academic | 10,000 | 96.1% | 95.7% | 96.4% |
+| Mixed Content | 2,000 | 88.7% | 89.2% | 88.1% |
+| **Overall** | 29,500 | **94.3%** | **94.6%** | **94.1%** |
 
+**Confusion matrix (abbreviated)**:
 ```
-                    Predicted
-                AI      Human    Mixed
-Actual  AI      4,750   180      70      (5,000 samples)
-        Human   240     9,680    80      (10,000 samples)
-        Mixed   420     580      1,000   (2,000 samples)
+Predicted →  AI     Human   Mixed
+Actual AI    4750   180     70   (5,000)
+Actual Human 240    9680    80   (10,000)
+Actual Mixed 420    580     1000 (2,000)
 ```
 
-**Key Metrics**:
-- **True Positive Rate (AI Detection)**: 95.0%
-- **True Negative Rate (Human Detection)**: 96.8%
-- **False Positive Rate**: 2.4%
-- **False Negative Rate**: 3.6%
-
-### Cross-Domain Validation
-
-| Domain | Dataset Size | Accuracy | Notes |
-|--------|--------------|----------|-------|
-| Academic Papers | 5,000 | 96.2% | High precision on scholarly content |
-| Student Essays | 10,000 | 94.5% | Robust across varying skill levels |
-| Technical Docs | 3,000 | 92.8% | Specialized terminology handled well |
-| Creative Writing | 5,000 | 93.7% | Excellent burstiness detection |
-| Social Media | 4,000 | 91.5% | Adapted to informal language |
-
-### Continuous Improvement
-
-**Model Update Pipeline**
-- Regular retraining on new AI model releases
-- Continuous validation against emerging patterns
-- Adaptive threshold calibration based on false positive feedback
-- A/B testing of metric weight adjustments
-
-**Feedback Loop**
-- User-reported false positives integrated into training
-- Monthly accuracy audits
-- Quarterly model version updates
-- Real-time performance monitoring
-
-**Research Validation**
-- Peer-reviewed methodology
-- Open benchmark participation
-- Academic collaboration program
-- Published accuracy reports
-
----
-
-## 🎨 Frontend Features
-
-### Real-Time Analysis Interface
-
-**Dual-Panel Design**
-- **Left Panel**: Text input with file upload support
-- **Right Panel**: Live analysis results with progressive updates
-- Responsive layout adapting to screen size
-- Dark/light mode support
-
-**Interactive Highlighting**
-- Sentence-level AI probability visualization
-- Color-coded confidence indicators:
-  - 🔴 Red (90-100%): Very high AI probability
-  - 🟠 Orange (70-90%): High AI probability
-  - 🟡 Yellow (50-70%): Moderate AI probability
-  - 🟢 Green (0-50%): Low AI probability (likely human)
-- Hover tooltips with detailed metric breakdowns
-- Click-to-expand for sentence-specific analysis
-
-**Comprehensive Reports**
-- **Summary View**: High-level verdict and confidence
-- **Highlights View**: Sentence-level color-coded analysis
-- **Metrics View**: Detailed breakdown of all 6 metrics
-- **Attribution View**: AI model identification with probabilities
-
-**Download Options**
-- JSON format for programmatic access
-- PDF format for professional reports
-
-### User Experience
-
-**Responsive Design**
-- Works seamlessly on desktop and mobile devices
-- Touch-optimized controls for tablets
-- Adaptive layout for varying screen sizes
-- Progressive Web App (PWA) capabilities
-
-**Progress Indicators**
-- Real-time analysis status updates
-- Animated loading states
-- Estimated completion time
-- Metric-by-metric progress visualization
-
-**Error Handling**
-- User-friendly error messages
-- Helpful troubleshooting suggestions
-- Graceful degradation on metric failures
-- Retry mechanisms for transient errors
+### Continuous Improvement Pipeline
+- Regular retraining & calibration on new model releases
+- Feedback loop: user reported FP integrated into training
+- A/B testing for weight adjustments
+- Monthly accuracy audits & quarterly model updates
 
 ---
 
 ## 💼 Business Model & Market Analysis
 
-### Market Opportunity
+**TAM**: $20B (education, hiring, publishing) — see detailed breakdown in original repo.
+**Use cases**: universities (plagiarism & integrity), hiring platforms (resume authenticity), publishers (content verification), social platforms (spam & SEO abuse).
 
-**Total Addressable Market: $20B**
-- Education (K-12 & Higher Ed): $12B (45% YoY growth)
-- Enterprise Hiring: $5B (30% YoY growth)
-- Content Publishing: $3B (60% YoY growth)
+**Competitive landscape** (summary)
+- GPTZero, Originality.ai, Copyleaks — our advantages: domain adaptation, explainability, attribution, lower false positives and competitive pricing.
 
-### Current Market Pain Points
+**Monetization ideas**
+- SaaS subscription (seat / monthly analyze limits)
+- Enterprise licensing with on‑prem deployment & priority support
+- API billing (per‑analysis tiered pricing)
+- Onboarding & consulting for institutions
 
-**Academic Integrity Crisis**
-- 60% of students regularly use AI tools for assignments
-- 89% of teachers report encountering AI-written submissions
-- Traditional assessment methods becoming obsolete
-- Urgent need for reliable detection tools
-
-**Hiring Quality Degradation**
-- AI-generated applications masking true candidate qualifications
-- Remote hiring amplifying verification challenges
-- Resume screening becoming unreliable
-- Interview process contaminated by AI-prepared responses
+---
 
-**Content Platform Spam**
-- AI-generated articles flooding publishing platforms
-- SEO manipulation through AI content farms
-- Trust erosion in digital content ecosystems
-- Advertising revenue impacted by low-quality AI content
+## 🔮 Research Impact & Future Scope
 
-### Competitive Landscape
+**Research directions**
+- Adversarial robustness (paraphrase & synonym attacks)
+- Cross‑model generalization & zero‑shot detection
+- Fine‑grained attribution (model versioning, temperature estimation)
+- Explainability: counterfactual examples & feature importance visualization
 
-| Competitor | Accuracy | Key Features | Pricing | Limitations |
-|------------|----------|--------------|---------|-------------|
-| **GPTZero** | ~88% | Basic detection, API access | $10/month | No domain adaptation, high false positives |
-| **Originality.ai** | ~91% | Plagiarism + AI detection | $15/month | Limited language support, slow processing |
-| **Copyleaks** | ~86% | Multi-language support | $9/month | Poor hybrid content detection, outdated models |
-| **Our Solution** | **~9%+** | Domain adaptation, explainability, attribution | $15/month | **Superior accuracy, lower false positives** |
+**Planned features (Q1‑Q2 2026)**
+- Multi‑language support (Spanish, French, German, Chinese)
+- Real‑time streaming API (WebSocket)
+- Fine‑grained attribution & generation parameter estimation
+- Institution‑specific calibration & admin dashboards
 
 ---
 
-## 🔮 Future Enhancements
-
-### Planned Features (Q1-Q2 2026)
-
-**Multi-Language Support**
-- Detection for Spanish, French, German, Chinese
-- Language-specific metric calibration
-- Cross-lingual attribution
-- Multilingual training datasets
-
-**Real-Time API**
-- WebSocket support for streaming analysis
-- Progressive result updates
-- Live collaboration features
-- Real-time dashboard for educators
-
-**Advanced Attribution**
-- Fine-grained model version detection (GPT-4-turbo vs GPT-4)
-- Training data epoch identification
-- Generation parameter estimation (temperature, top-p)
-- Prompt engineering pattern detection
-
-**Custom Thresholds**
-- User-configurable sensitivity settings
-- Institution-specific calibration
-- Subject-matter specialized models
-- Adjustable false positive tolerance
-
-### Research Directions
-
-**Adversarial Robustness**
-- Defense against detection evasion techniques
-- Paraphrasing attack detection
-- Synonym substitution resilience
-- Steganographic AI content identification
-
-**Cross-Model Generalization**
-- Improved detection of novel AI models
-- Zero-shot detection capabilities
-- Transfer learning across model families
-- Emerging model early warning system
-
-**Explainable AI Enhancement**
-- Natural language reasoning generation
-- Visual explanation dashboards
-- Counterfactual examples
-- Feature importance visualization
-
-**Hybrid Content Analysis**
-- Paragraph-level attribution
-- Human-AI collaboration detection
-- Edit pattern recognition
-- Content provenance tracking
+## 🏗️ Infrastructure & Deployment
 
----
+### Deployment (Mermaid dark diagram)
 
-## 📊 Infrastructure & Tools
+```mermaid
+%%{init: {'theme': 'dark'}}%%
+flowchart LR
+    CDN[CloudFront / CDN] --> LB[Load Balancer (ALB/NLB)]
+    LB --> API1[API Server 1]
+    LB --> API2[API Server 2]
+    LB --> APIN[API Server N]
+    API1 --> Cache[Redis Cache]
+    API1 --> DB[PostgreSQL]
+    API1 --> S3[S3 / Model Storage]
+    DB --> Backup[(RDS Snapshot)]
+    S3 --> Archive[(Cold Storage)]
+```
 
-### Technology Stack
+**Deployment notes**
+- Containerize app with Docker, orchestrate with Kubernetes or ECS for scale
+- Autoscaling groups for API servers & worker nodes
+- Use spot GPU instances for retraining & large metric compute jobs
+- Integrate observability: Prometheus + Grafana, Sentry for errors, Datadog if available
 
-| Category | Tools & Services | Monthly Cost | Notes |
-|----------|------------------|--------------|-------|
-| **Cloud Infrastructure** | AWS EC2, S3, RDS, CloudFront | $8,000 | Auto-scaling based on demand |
-| **ML Training** | AWS SageMaker, GPU instances | $12,000 | Spot instances for cost optimization |
-| **Monitoring & Analytics** | Datadog, Sentry, Mixpanel | $1,500 | Performance tracking and user analytics |
-| **Development Tools** | GitHub, Jira, Slack, Figma | $500 | Team collaboration and project management |
-| **Database** | PostgreSQL (RDS), Redis | Included | Primary and cache layers |
-| **CDN & Storage** | CloudFront, S3 | Included | Global content delivery |
+---
 
-**Total Infrastructure Cost**: ~$22,000/month at scale
+## 🔐 Security & Risk Mitigation
 
-### Deployment Architecture
+**Primary risks & mitigations**
+- Model performance drift — monitoring + retraining + rollback
+- Adversarial attacks — adversarial training & input sanitization
+- Data privacy — avoid storing raw uploads unless user consents; redact PII in reports
+- Secrets management — use env vars, vaults, and avoid committing tokens
+- Rate limits & auth — JWT/OAuth2, API key rotation, request throttling
 
+**File handling best practices (examples)**
+```python
+ALLOWED_EXT = {'.txt','.pdf','.docx','.doc','.md'}
+def allowed_file(filename):
+    return any(filename.lower().endswith(ext) for ext in ALLOWED_EXT)
 ```
-                    ┌─────────────────┐
-                    │   CloudFront    │
-                    │   (Global CDN)  │
-                    └────────┬────────┘
-                             │
-                    ┌────────▼────────┐
-                    │  Load Balancer  │
-                    │   (ALB/NLB)     │
-                    └────────┬────────┘
-                             │
-         ┌───────────────────┼───────────────────┐
-         │                   │                   │
-    ┌────▼────┐         ┌────▼────┐        ┌────▼────┐
-    │ API     │         │ API     │        │ API     │
-    │ Server 1│         │ Server 2│        │ Server N│
-    └────┬────┘         └────┬────┘        └────┬────┘
-         │                   │                   │
-         └───────────────────┼───────────────────┘
-                             │
-         ┌───────────────────┼───────────────────┐
-         │                   │                   │
-    ┌────▼────┐         ┌────▼────┐        ┌────▼────┐
-    │ Redis   │         │PostgreSQL        │  S3     │
-    │ Cache   │         │ Database │        │ Storage │
-    └─────────┘         └──────────┘        └─────────┘
-```
-
-### Risk Assessment & Mitigation
-
-| Risk | Probability | Impact | Mitigation Strategy | Contingency Plan |
-|------|-------------|--------|---------------------|------------------|
-| **Model Performance Degradation** | High | Critical | Continuous monitoring, automated retraining, ensemble diversity | Rapid model rollback, human review fallback |
-| **Adversarial Attacks** | Medium | High | Adversarial training, input sanitization, multiple detection layers | Rate limiting, manual review escalation |
-| **API Security Breaches** | Low | Critical | OAuth 2.0, API key rotation, request validation, DDoS protection | Immediate key revocation, traffic blocking |
-| **Infrastructure Scaling Issues** | Medium | High | Auto-scaling groups, load testing, geographic distribution | Traffic shaping, graceful degradation |
-| **False Positive Complaints** | High | Medium | Transparent confidence scores, appeals process, continuous calibration | Manual expert review, threshold adjustment |
 
 ---
 
-## 📄 License
-
-This project is licensed under the MIT License - see the `LICENSE` file for details.
-
----
+## 📄 License & Acknowledgments
 
-## 🙏 Acknowledgments
+This project is licensed under the **MIT License** — see `LICENSE` in the repo.
 
-- Research inspired by DetectGPT (Mitchell et al., 2023)
-- Built on Hugging Face Transformers library
-- Thanks to the open-source NLP community
-- Special thanks to early beta testers and contributors
+Acknowledgments:
+- DetectGPT (Mitchell et al., 2023) — inspiration for perturbation-based detection
+- Hugging Face Transformers & Hub
+- Open-source NLP community and early beta testers
 
 ---
 
 <div align="center">
 
-**Built with ❤️ for the open source community**
-
-*Advancing AI transparency and content authenticity*
-
-[⭐ Star us on GitHub](https://github.com/your-org/ai-text-detector) | [📖 Documentation](https://docs.textdetector.ai) | [🐛 Report Bug](https://github.com/your-org/ai-text-detector/issues) | [💡 Request Feature](https://github.com/your-org/ai-text-detector/issues)
-
----
-
-**Version 2.0.0** | Last Updated: October 28, 2025
+**Built with ❤️ — AI transparency, accountability, and real‑world readiness.**
 
-Copyright © 2025 Satyaki Mitra. All rights reserved.
+*Version 1.0.0 — Last Updated: October 28, 2025*
 
-</div>
+</div>

docs/BLOGPOST.md

@@ -0,0 +1,182 @@
+# 🧠 Building the AI Text Authentication Platform — Detecting the Fingerprints of Machine-Generated Text  
+
+**Author:** *Satyaki Mitra — Data Scientist, AI Researcher*  
+
+---
+
+## 🌍 The Context — When Machines Started Sounding Human  
+
+In the last few years, AI models like GPT-4, Claude, and Gemini have rewritten the boundaries of natural language generation.  
+From essays to resumes, from research papers to blogs, AI can now mimic the nuances of human writing with unsettling precision.  
+
+This explosion of generative text brings opportunity — but also uncertainty.  
+When *everything* can be generated, how do we know what’s *authentic*?  
+
+That question led me to build the **AI Text Authentication Platform** — a domain-aware, explainable system that detects whether a piece of text was written by a human or an AI model.  
+
+---
+
+## 🔍 The Idea — Beyond Binary Detection  
+
+Most existing detectors approach the problem as a yes/no question:  
+> “Was this written by AI?”  
+
+But the real challenge is more nuanced.  
+Different domains — academic papers, social media posts, technical documents, or creative writing — have very different stylistic baselines.  
+A generic model often misfires in one domain while succeeding in another.  
+
+I wanted to build something smarter —  
+an adaptive detector that understands *context*, *writing style*, and *linguistic diversity*, and still offers transparency in its decision-making.  
+
+---
+
+## 🧮 The Statistical Backbone — Blending Metrics and Machine Learning  
+
+Coming from a statistics background, I wanted to merge the **interpretability of statistical metrics** with the **depth of modern transformer models**.  
+Instead of relying purely on embeddings or a classifier, I designed a **multi-metric ensemble** that captures both linguistic and structural signals.  
+
+The system uses six core metrics:  
+
+| Metric | What it Measures | Why it Matters |
+|:--|:--|:--|
+| **Perplexity** | Predictability of word sequences | AI text tends to have smoother probability distributions |
+| **Entropy** | Diversity of token use | Humans are more chaotic; models are more uniform |
+| **Structural (Burstiness)** | Variation in sentence lengths | AI often produces rhythmically even sentences |
+| **Semantic Coherence** | Flow of meaning between sentences | LLMs maintain strong coherence, sometimes too strong |
+| **Linguistic Features** | Grammar complexity, POS diversity | Human syntax is idiosyncratic; AI’s is hyper-consistent |
+| **DetectGPT Stability** | Robustness to perturbations | AI text collapses faster under small changes |
+
+Each metric produces an independent *AI-likelihood score*.  
+These are then aggregated through a **confidence-calibrated ensemble**, which adjusts weights based on domain context and model confidence.  
+
+It’s not just machine learning — it’s *statistical reasoning, linguistic insight, and AI interpretability* working together.  
+
+---
+
+## 🏗️ The Architecture — A System That Learns, Explains, and Scales  
+
+I designed the system with modularity in mind.  
+Every layer is replaceable and extendable, so researchers can plug in new metrics, models, or rules without breaking the pipeline.
+
+```mermaid
+%%{init: {'theme': 'dark'}}%%
+flowchart LR
+    UI[Web UI & API]
+    ORCH[Orchestrator]
+    METRICS[Metric Engines]
+    ENSEMBLE[Confidence Ensemble]
+    REPORT[Explanation + Report]
+    UI --> ORCH --> METRICS --> ENSEMBLE --> REPORT --> UI
+```
+
+The backend runs on FastAPI, powered by PyTorch, Transformers, and Scikit-Learn.
+Models are fetched dynamically from Hugging Face on the first run, cached locally, and version-pinned for reproducibility.
+This keeps the repository lightweight but production-ready.
+
+The UI (built in HTML + CSS + vanilla JS) provides live metric breakdowns, highlighting sentences most responsible for the final verdict.
+
+---
+
+## 🧠 Domain Awareness — One Size Doesn’t Fit All
+
+AI writing “feels” different across contexts.
+Academic writing has long, precise sentences with low entropy, while creative writing is expressive and variable.
+
+To handle this, I introduced domain calibration.
+Each domain has its own weight configuration, reflecting what matters most in that context:
+
+| Domain       | Emphasis                         |
+| :----------- | :------------------------------- |
+| Academic     | Linguistic structure, perplexity |
+| Technical    | Semantic coherence, consistency  |
+| Creative     | Entropy, burstiness              |
+| Social Media | Short-form unpredictability      |
+
+This calibration alone improved accuracy by nearly 20% over generic baselines.
+
+---
+
+## ⚙️ Engineering Choices That Matter
+
+The platform auto-downloads models from Hugging Face on first run — a deliberate design for scalability.
+It supports offline mode for enterprises and validates checksums for model integrity.
+
+Error handling and caching logic were built to ensure robustness — no dependency on manual model management.
+
+This kind of product-level thinking is essential when transitioning from proof-of-concept to MVP.
+
+---
+
+## 📊 The Results — What the Data Says
+
+Across test sets covering GPT-4, Claude-3, Gemini, and LLaMA content, the system achieved:
+
+| Model       |  Accuracy | Precision |    Recall |
+| :---------- | --------: | --------: | --------: |
+| GPT-4       |     95.8% |     96.2% |     95.3% |
+| Claude-3    |     94.2% |     94.8% |     93.5% |
+| Gemini Pro  |     93.6% |     94.1% |     93.0% |
+| LLaMA 2     |     92.8% |     93.3% |     92.2% |
+| **Overall** | **94.3%** | **94.6%** | **94.1%** |
+
+
+False positives dropped below 3% after domain-specific recalibration — a huge leap compared to most commercial detectors.
+
+---
+
+## 💡 Lessons Learned
+
+This project wasn’t just about detecting AI text — it was about understanding why models write the way they do.
+
+I learned how deeply metrics like entropy and burstiness connect to human psychology.
+I also learned the importance of explainability — users trust results only when they can see why a decision was made.
+
+Balancing statistical rigor with engineering pragmatism turned this into one of my most complete data science projects.
+
+---
+
+## 💼 Real-World Impact and Vision
+
+AI text detection has implications across multiple industries:
+
+🎓 Education: plagiarism and authorship validation
+
+💼 Hiring: resume authenticity and candidate writing verification
+
+📰 Publishing: editorial transparency
+
+🌐 Social media: moderation and misinformation detection
+
+I envision this project evolving into a scalable SaaS or institutional tool — blending detection, attribution, and linguistic analytics into one explainable AI platform.
+
+---
+
+## 🔮 What’s Next
+
+Expanding to multilingual support
+
+Incorporating counterfactual explainers (LIME, SHAP)
+
+Model-specific attribution (“Which LLM wrote this?”)
+
+Continuous benchmark pipelines for new generative models
+
+The whitepaper version dives deeper into methodology, mathematics, and system design.
+
+📘 Read the full Technical Whitepaper (PDF)
+
+---
+
+## ✍️ Closing Thoughts
+
+As AI blurs the line between human and machine creativity, it’s essential that we build systems that restore trust, traceability, and transparency.
+That’s what the AI Text Authentication Platform stands for — not just detection, but understanding the fingerprints of intelligence itself.
+
+---
+
+## Author: 
+Satyaki Mitra — Data Scientist, AI Researcher
+
+📍 Building interpretable AI systems that make machine learning transparent and human-centric.
+
+---