diff --git a/config/config.fusion-example.yaml b/config/config.fusion-example.yaml
new file mode 100644
index 00000000..7058b3d7
--- /dev/null
+++ b/config/config.fusion-example.yaml
@@ -0,0 +1,169 @@
+# Example Router Configuration with Signal Fusion Engine
+# This is a complete example showing how to integrate the fusion engine
+
+# Standard BERT model configuration (existing)
+bert_model:
+  model_id: sentence-transformers/all-MiniLM-L12-v2
+  threshold: 0.6
+  use_cpu: true
+
+# Classifier configuration (existing)
+classifier:
+  category_model:
+    model_id: "models/classifier_modernbert-base_model"
+    threshold: 0.5
+    use_cpu: true
+    use_modernbert: true
+    category_mapping_path: "models/classifier_modernbert-base_model/category_mapping.json"
+  
+  pii_model:
+    model_id: "models/pii_classifier_modernbert-base_model"
+    threshold: 0.7
+    use_cpu: true
+    pii_mapping_path: "models/pii_classifier_modernbert-base_model/pii_type_mapping.json"
+
+# Prompt guard configuration (existing)
+prompt_guard:
+  enabled: true
+  use_modernbert: true
+  model_id: "models/jailbreak_classifier_modernbert-base_model"
+  threshold: 0.7
+  use_cpu: true
+  jailbreak_mapping_path: "models/jailbreak_classifier_modernbert-base_model/jailbreak_type_mapping.json"
+
+# ============================================================
+# NEW: Content Scanning and Signal Fusion Configuration
+# ============================================================
+
+content_scanning:
+  # Enable the fusion engine
+  enabled: true
+  
+  # Default action when no rules match
+  # Options: "fallthrough" (use BERT), "block"
+  default_action: "fallthrough"
+  
+  # Enable audit logging for policy decisions
+  audit_logging: true
+  
+  # Signal provider configurations
+  providers:
+    # Keyword matching provider (in-tree, low latency)
+    keyword:
+      enabled: true
+      rules_path: "config/fusion/keyword_rules.yaml"
+    
+    # Regex scanning provider (in-tree, low latency)
+    regex:
+      enabled: true
+      patterns_path: "config/fusion/regex_patterns.yaml"
+      engine: "re2"  # Options: "re2" (recommended), "stdlib"
+    
+    # Embedding similarity provider (in-tree or MCP)
+    similarity:
+      enabled: true
+      concepts_path: "config/fusion/similarity_concepts.yaml"
+      default_threshold: 0.75
+  
+  # Fusion policy - combines all signals into routing decisions
+  fusion_policy:
+    # Option 1: Load rules from external file (recommended for production)
+    rules_path: "config/fusion/policy_rules.yaml"
+    
+    # Option 2: Inline rules (good for simple configurations)
+    # rules:
+    #   - name: "block-pii"
+    #     condition: "regex.ssn.matched || regex.credit-card.matched"
+    #     action: "block"
+    #     priority: 200
+    #     message: "PII detected"
+    #   
+    #   - name: "route-k8s"
+    #     condition: "keyword.kubernetes-infrastructure.matched && similarity.infrastructure.score > 0.75"
+    #     action: "route"
+    #     priority: 150
+    #     models: ["k8s-expert", "devops-model"]
+    #   
+    #   - name: "default"
+    #     condition: "!regex.ssn.matched"
+    #     action: "fallthrough"
+    #     priority: 0
+
+# ============================================================
+# Standard Router Configuration (existing)
+# ============================================================
+
+# Categories for routing (existing)
+categories:
+  - name: "computer science"
+    model_scores:
+      qwen-2.5:3b-instruct: 0.78
+      tinyllama-1.1b-chat: 0.65
+    use_reasoning: true
+    reasoning_effort: "medium"
+  
+  - name: "math"
+    model_scores:
+      qwen-2.5:3b-instruct: 0.85
+      tinyllama-1.1b-chat: 0.45
+    use_reasoning: true
+    reasoning_effort: "high"
+  
+  - name: "business"
+    model_scores:
+      qwen-2.5:3b-instruct: 0.72
+      tinyllama-1.1b-chat: 0.68
+    use_reasoning: false
+    reasoning_effort: "low"
+
+# Default model
+default_model: "qwen-2.5:3b-instruct"
+
+# Default reasoning effort
+default_reasoning_effort: "medium"
+
+# vLLM Endpoints
+vllm_endpoints:
+  - name: "qwen-endpoint"
+    address: "127.0.0.1"
+    port: 8000
+    weight: 1
+    health_check_path: "/health"
+
+# Semantic cache configuration
+semantic_cache:
+  enabled: true
+  backend_type: "memory"
+  similarity_threshold: 0.8
+  max_entries: 1000
+  ttl_seconds: 3600
+
+# Tools configuration
+tools:
+  enabled: true
+  top_k: 3
+  similarity_threshold: 0.2
+  tools_db_path: "config/tools_db.json"
+  fallback_to_empty: true
+
+# API configuration
+api:
+  batch_classification:
+    metrics:
+      enabled: true
+      sample_rate: 1.0
+
+# Observability configuration
+observability:
+  tracing:
+    enabled: false
+    provider: "opentelemetry"
+    exporter:
+      type: "otlp"
+      endpoint: "localhost:4317"
+      insecure: true
+    sampling:
+      type: "always_on"
+    resource:
+      service_name: "semantic-router"
+      deployment_environment: "development"
diff --git a/config/fusion/keyword_rules.yaml b/config/fusion/keyword_rules.yaml
new file mode 100644
index 00000000..122158cf
--- /dev/null
+++ b/config/fusion/keyword_rules.yaml
@@ -0,0 +1,106 @@
+# Keyword Rules Configuration
+# Defines keyword matching rules for deterministic routing
+
+rules:
+  # Infrastructure and DevOps keywords
+  - name: "kubernetes-infrastructure"
+    description: "Kubernetes and container orchestration terms"
+    keywords:
+      - "kubernetes"
+      - "k8s"
+      - "kubectl"
+      - "helm"
+      - "pod"
+      - "deployment"
+      - "service mesh"
+      - "istio"
+      - "kustomize"
+    operator: "OR"  # Match if ANY keyword is found
+    case_sensitive: false
+  
+  - name: "docker"
+    description: "Docker and containerization terms"
+    keywords:
+      - "docker"
+      - "container"
+      - "dockerfile"
+      - "docker-compose"
+      - "docker image"
+      - "docker container"
+    operator: "OR"
+    case_sensitive: false
+  
+  # Database keywords
+  - name: "database"
+    description: "Database and SQL terms"
+    keywords:
+      - "database"
+      - "sql"
+      - "mysql"
+      - "postgresql"
+      - "mongodb"
+      - "redis"
+      - "query optimization"
+      - "index"
+      - "transaction"
+    operator: "OR"
+    case_sensitive: false
+  
+  # Security keywords
+  - name: "security"
+    description: "Security and cybersecurity terms"
+    keywords:
+      - "security"
+      - "vulnerability"
+      - "exploit"
+      - "firewall"
+      - "encryption"
+      - "authentication"
+      - "authorization"
+      - "penetration test"
+    operator: "OR"
+    case_sensitive: false
+  
+  # Programming keywords
+  - name: "programming"
+    description: "Programming and software development terms"
+    keywords:
+      - "code"
+      - "function"
+      - "class"
+      - "algorithm"
+      - "debug"
+      - "refactor"
+      - "unit test"
+      - "programming"
+    operator: "OR"
+    case_sensitive: false
+  
+  # Mathematics keywords
+  - name: "mathematics"
+    description: "Mathematics and computation terms"
+    keywords:
+      - "calculus"
+      - "derivative"
+      - "integral"
+      - "matrix"
+      - "algebra"
+      - "geometry"
+      - "probability"
+      - "statistics"
+    operator: "OR"
+    case_sensitive: false
+  
+  # Performance keywords
+  - name: "performance"
+    description: "Performance optimization terms"
+    keywords:
+      - "performance"
+      - "optimization"
+      - "latency"
+      - "throughput"
+      - "bottleneck"
+      - "profiling"
+      - "benchmark"
+    operator: "OR"
+    case_sensitive: false
diff --git a/config/fusion/policy_rules.yaml b/config/fusion/policy_rules.yaml
new file mode 100644
index 00000000..793c3f4c
--- /dev/null
+++ b/config/fusion/policy_rules.yaml
@@ -0,0 +1,118 @@
+# Signal Fusion Policy Rules Configuration
+# This file defines the fusion policy rules that combine signals into routing decisions
+
+rules:
+  # ============================================================
+  # PRIORITY 200: Safety Blocks
+  # These rules have the highest priority and block dangerous requests
+  # ============================================================
+  
+  - name: "block-ssn-pattern"
+    condition: "regex.ssn.matched"
+    action: "block"
+    priority: 200
+    message: "Request contains Social Security Number pattern and cannot be processed for security reasons"
+  
+  - name: "block-credit-card"
+    condition: "regex.credit-card.matched"
+    action: "block"
+    priority: 200
+    message: "Request contains credit card number pattern and cannot be processed for security reasons"
+  
+  - name: "block-combined-pii"
+    condition: "regex.ssn.matched || regex.credit-card.matched || regex.email-with-password.matched"
+    action: "block"
+    priority: 200
+    message: "PII detected - request blocked for security compliance"
+  
+  # ============================================================
+  # PRIORITY 150: High-Confidence Routing
+  # These rules route to specialized models when multiple signals agree
+  # ============================================================
+  
+  - name: "route-kubernetes-expert"
+    condition: "keyword.kubernetes-infrastructure.matched && similarity.infrastructure.score > 0.75"
+    action: "route"
+    priority: 150
+    models:
+      - "k8s-expert"
+      - "devops-model"
+  
+  - name: "route-security-expert"
+    condition: "(keyword.security.matched || regex.cve-id.matched) && bert.category.value == 'computer science'"
+    action: "route"
+    priority: 150
+    models:
+      - "security-hardened-model"
+      - "cybersecurity-specialist"
+  
+  - name: "route-database-expert"
+    condition: "keyword.database.matched && similarity.database.score > 0.8"
+    action: "route"
+    priority: 150
+    models:
+      - "db-expert"
+      - "sql-specialist"
+  
+  - name: "route-docker-expert"
+    condition: "keyword.docker.matched && (similarity.containers.score > 0.75 || bert.category.value == 'computer science')"
+    action: "route"
+    priority: 150
+    models:
+      - "docker-expert"
+      - "containerization-specialist"
+  
+  # ============================================================
+  # PRIORITY 100: Category Boosting
+  # These rules boost BERT category weights based on signal detection
+  # ============================================================
+  
+  - name: "boost-reasoning-category"
+    condition: "similarity.reasoning.score > 0.75"
+    action: "boost_category"
+    priority: 100
+    category: "reasoning"
+    boost_weight: 1.5
+  
+  - name: "boost-math-category"
+    condition: "keyword.mathematics.matched || similarity.mathematics.score > 0.7"
+    action: "boost_category"
+    priority: 100
+    category: "math"
+    boost_weight: 1.4
+  
+  - name: "boost-code-generation"
+    condition: "keyword.programming.matched && similarity.code-generation.score > 0.7"
+    action: "boost_category"
+    priority: 100
+    category: "computer science"
+    boost_weight: 1.3
+  
+  # ============================================================
+  # PRIORITY 50: Multi-Signal Consensus
+  # These rules require multiple independent signals to agree
+  # ============================================================
+  
+  - name: "consensus-k8s-security"
+    condition: "keyword.kubernetes-infrastructure.matched && keyword.security.matched && similarity.infrastructure.score > 0.8 && bert.category.value == 'computer science'"
+    action: "route"
+    priority: 50
+    models:
+      - "k8s-security-expert"
+  
+  - name: "consensus-database-performance"
+    condition: "keyword.database.matched && keyword.performance.matched && similarity.database.score > 0.75"
+    action: "route"
+    priority: 50
+    models:
+      - "db-performance-expert"
+  
+  # ============================================================
+  # PRIORITY 0: Default Fallthrough
+  # This rule catches all non-blocked requests and uses BERT
+  # ============================================================
+  
+  - name: "default-fallthrough"
+    condition: "!regex.ssn.matched && !regex.credit-card.matched"
+    action: "fallthrough"
+    priority: 0
diff --git a/config/fusion/regex_patterns.yaml b/config/fusion/regex_patterns.yaml
new file mode 100644
index 00000000..25da14cf
--- /dev/null
+++ b/config/fusion/regex_patterns.yaml
@@ -0,0 +1,59 @@
+# Regex Patterns Configuration
+# Defines regular expression patterns for security scanning and structured data detection
+
+patterns:
+  # PII Detection Patterns
+  - name: "ssn"
+    description: "Social Security Number (XXX-XX-XXXX format)"
+    pattern: '\b\d{3}-\d{2}-\d{4}\b'
+    action: "block"
+  
+  - name: "credit-card"
+    description: "Credit card number (various formats)"
+    pattern: '\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b'
+    action: "block"
+  
+  - name: "email-with-password"
+    description: "Email and password in the same query (potential credential leak)"
+    pattern: '(?i)(email|username).*password|password.*(?:email|username)'
+    action: "block"
+  
+  # Security Pattern Detection
+  - name: "cve-id"
+    description: "CVE (Common Vulnerabilities and Exposures) identifier"
+    pattern: 'CVE-\d{4}-\d{4,7}'
+    action: "route"
+    models:
+      - "security-expert"
+  
+  - name: "ip-address"
+    description: "IPv4 address pattern"
+    pattern: '\b(?:\d{1,3}\.){3}\d{1,3}\b'
+    action: "log"
+  
+  - name: "aws-access-key"
+    description: "AWS Access Key ID pattern"
+    pattern: '(?i)(?:AKIA|A3T|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[0-9A-Z]{16}'
+    action: "block"
+  
+  # Structured Data Detection
+  - name: "url"
+    description: "URL pattern"
+    pattern: 'https?://[^\s]+'
+    action: "log"
+  
+  - name: "github-issue"
+    description: "GitHub issue reference (e.g., #123)"
+    pattern: '#\d{1,5}\b'
+    action: "log"
+  
+  # Code Pattern Detection
+  - name: "sql-injection-attempt"
+    description: "Potential SQL injection pattern"
+    pattern: "(?i)(?:union.*select|select.*from.*where|insert.*into|delete.*from|drop.*table|'.*or.*'.*=.*')"
+    action: "block"
+  
+  - name: "command-injection"
+    description: "Potential command injection pattern"
+    pattern: '(?:;|\||`|&|\$\(|\${).*(?:rm|cat|ls|wget|curl|bash|sh)'
+    action: "block"
diff --git a/config/fusion/similarity_concepts.yaml b/config/fusion/similarity_concepts.yaml
new file mode 100644
index 00000000..d3a94a0d
--- /dev/null
+++ b/config/fusion/similarity_concepts.yaml
@@ -0,0 +1,81 @@
+# Embedding Similarity Concepts Configuration
+# Defines semantic concepts for embedding similarity detection
+
+concepts:
+  # Reasoning and problem-solving concepts
+  - name: "reasoning"
+    description: "Multi-step reasoning and problem solving"
+    keywords:
+      - "step by step"
+      - "solve this problem"
+      - "explain your reasoning"
+      - "break down the solution"
+      - "think through this"
+      - "logical steps"
+    threshold: 0.75
+    aggregate_method: "mean"  # Options: mean, max, any
+  
+  - name: "mathematics"
+    description: "Mathematical problem solving"
+    keywords:
+      - "solve the equation"
+      - "calculate the derivative"
+      - "find the integral"
+      - "prove the theorem"
+    threshold: 0.7
+    aggregate_method: "mean"
+  
+  # Infrastructure concepts
+  - name: "infrastructure"
+    description: "Cloud infrastructure and DevOps concepts"
+    keywords:
+      - "deploy kubernetes cluster"
+      - "configure cloud infrastructure"
+      - "set up container orchestration"
+      - "manage microservices"
+      - "scale distributed system"
+    threshold: 0.75
+    aggregate_method: "max"
+  
+  - name: "containers"
+    description: "Container and Docker concepts"
+    keywords:
+      - "build docker image"
+      - "containerize application"
+      - "docker compose setup"
+      - "multi-stage dockerfile"
+    threshold: 0.75
+    aggregate_method: "max"
+  
+  # Database concepts
+  - name: "database"
+    description: "Database design and optimization"
+    keywords:
+      - "optimize database query"
+      - "design database schema"
+      - "improve query performance"
+      - "database indexing strategy"
+    threshold: 0.8
+    aggregate_method: "mean"
+  
+  # Code generation concepts
+  - name: "code-generation"
+    description: "Code writing and generation"
+    keywords:
+      - "write a function to"
+      - "implement an algorithm"
+      - "create a class that"
+      - "generate code for"
+    threshold: 0.7
+    aggregate_method: "max"
+  
+  # Security concepts
+  - name: "security-analysis"
+    description: "Security analysis and vulnerability assessment"
+    keywords:
+      - "security vulnerability assessment"
+      - "penetration testing approach"
+      - "threat modeling for"
+      - "security best practices"
+    threshold: 0.75
+    aggregate_method: "mean"
diff --git a/src/semantic-router/pkg/utils/fusion/CONFIGURATION.md b/src/semantic-router/pkg/utils/fusion/CONFIGURATION.md
new file mode 100644
index 00000000..9b695804
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/CONFIGURATION.md
@@ -0,0 +1,593 @@
+# Signal Fusion Engine Configuration Guide
+
+This guide shows how to configure and use the Signal Fusion Engine with the semantic router.
+
+## Table of Contents
+
+1. [Configuration Structure](#configuration-structure)
+2. [YAML Configuration Examples](#yaml-configuration-examples)
+3. [Integration with Router](#integration-with-router)
+4. [Complete Examples](#complete-examples)
+
+## Configuration Structure
+
+### Adding to RouterConfig
+
+To integrate the fusion engine, add the following to your `RouterConfig` in `pkg/config/config.go`:
+
+```go
+type RouterConfig struct {
+    // ... existing fields ...
+    
+    // Content Scanning and Signal Fusion configuration
+    ContentScanning ContentScanningConfig `yaml:"content_scanning,omitempty"`
+}
+
+// ContentScanningConfig represents the signal fusion configuration
+type ContentScanningConfig struct {
+    // Enable/disable the entire content scanning system
+    Enabled bool `yaml:"enabled"`
+    
+    // Default action when no rules match (fallthrough or block)
+    DefaultAction string `yaml:"default_action,omitempty"`
+    
+    // Enable audit logging for policy decisions
+    AuditLogging bool `yaml:"audit_logging,omitempty"`
+    
+    // In-tree signal providers
+    Providers ProvidersConfig `yaml:"providers,omitempty"`
+    
+    // Fusion policy configuration
+    FusionPolicy FusionPolicyConfig `yaml:"fusion_policy"`
+}
+
+// ProvidersConfig represents signal provider configurations
+type ProvidersConfig struct {
+    // Keyword matching provider
+    Keyword KeywordProviderConfig `yaml:"keyword,omitempty"`
+    
+    // Regex scanning provider
+    Regex RegexProviderConfig `yaml:"regex,omitempty"`
+    
+    // Embedding similarity provider
+    Similarity SimilarityProviderConfig `yaml:"similarity,omitempty"`
+}
+
+// KeywordProviderConfig represents keyword matching configuration
+type KeywordProviderConfig struct {
+    Enabled   bool   `yaml:"enabled"`
+    RulesPath string `yaml:"rules_path,omitempty"`
+}
+
+// RegexProviderConfig represents regex scanning configuration
+type RegexProviderConfig struct {
+    Enabled      bool   `yaml:"enabled"`
+    PatternsPath string `yaml:"patterns_path,omitempty"`
+    Engine       string `yaml:"engine,omitempty"` // "re2" or "stdlib"
+}
+
+// SimilarityProviderConfig represents embedding similarity configuration
+type SimilarityProviderConfig struct {
+    Enabled         bool    `yaml:"enabled"`
+    ConceptsPath    string  `yaml:"concepts_path,omitempty"`
+    DefaultThreshold float64 `yaml:"default_threshold,omitempty"`
+}
+
+// FusionPolicyConfig represents fusion policy configuration
+type FusionPolicyConfig struct {
+    // Path to fusion policy rules file
+    RulesPath string `yaml:"rules_path"`
+    
+    // Inline rules (alternative to rules_path)
+    Rules []FusionRule `yaml:"rules,omitempty"`
+}
+
+// FusionRule represents a single fusion policy rule
+type FusionRule struct {
+    Name        string   `yaml:"name"`
+    Condition   string   `yaml:"condition"`
+    Action      string   `yaml:"action"` // "block", "route", "boost_category", "fallthrough"
+    Priority    int      `yaml:"priority"`
+    Models      []string `yaml:"models,omitempty"`
+    Category    string   `yaml:"category,omitempty"`
+    BoostWeight float64  `yaml:"boost_weight,omitempty"`
+    Message     string   `yaml:"message,omitempty"`
+}
+```
+
+## YAML Configuration Examples
+
+### Basic Configuration
+
+Add this to your `config.yaml`:
+
+```yaml
+content_scanning:
+  enabled: true
+  default_action: fallthrough
+  audit_logging: true
+  
+  providers:
+    keyword:
+      enabled: true
+      rules_path: "config/fusion/keyword_rules.yaml"
+    
+    regex:
+      enabled: true
+      patterns_path: "config/fusion/regex_patterns.yaml"
+      engine: "re2"
+    
+    similarity:
+      enabled: true
+      concepts_path: "config/fusion/similarity_concepts.yaml"
+      default_threshold: 0.75
+  
+  fusion_policy:
+    rules_path: "config/fusion/policy_rules.yaml"
+```
+
+### Inline Policy Rules
+
+Alternatively, define rules inline:
+
+```yaml
+content_scanning:
+  enabled: true
+  default_action: fallthrough
+  
+  fusion_policy:
+    rules:
+      # Safety blocks - highest priority
+      - name: "block-ssn"
+        condition: "regex.ssn.matched"
+        action: "block"
+        priority: 200
+        message: "Request contains SSN pattern and cannot be processed"
+      
+      - name: "block-credit-card"
+        condition: "regex.credit-card.matched"
+        action: "block"
+        priority: 200
+        message: "Request contains credit card pattern and cannot be processed"
+      
+      # High-confidence routing
+      - name: "route-kubernetes"
+        condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.75"
+        action: "route"
+        priority: 150
+        models: ["k8s-expert", "devops-model"]
+      
+      - name: "route-security"
+        condition: "keyword.security.matched && bert.category.value == 'computer science'"
+        action: "route"
+        priority: 150
+        models: ["security-hardened-model"]
+      
+      # Category boosting
+      - name: "boost-reasoning"
+        condition: "similarity.reasoning.score > 0.75"
+        action: "boost_category"
+        priority: 100
+        category: "reasoning"
+        boost_weight: 1.5
+      
+      # Default fallthrough
+      - name: "default-fallthrough"
+        condition: "!regex.ssn.matched"
+        action: "fallthrough"
+        priority: 0
+```
+
+### External Rules Files
+
+**config/fusion/keyword_rules.yaml:**
+```yaml
+rules:
+  - name: "kubernetes-infrastructure"
+    keywords: ["kubernetes", "k8s", "kubectl", "helm", "pod", "deployment"]
+    operator: "OR"
+    case_sensitive: false
+  
+  - name: "security"
+    keywords: ["security", "vulnerability", "CVE", "exploit", "firewall"]
+    operator: "OR"
+    case_sensitive: false
+  
+  - name: "docker"
+    keywords: ["docker", "container", "dockerfile", "docker-compose"]
+    operator: "OR"
+    case_sensitive: false
+```
+
+**config/fusion/regex_patterns.yaml:**
+```yaml
+patterns:
+  - name: "ssn"
+    pattern: '\b\d{3}-\d{2}-\d{4}\b'
+    description: "Social Security Number pattern"
+  
+  - name: "credit-card"
+    pattern: '\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b'
+    description: "Credit card number pattern"
+  
+  - name: "cve-id"
+    pattern: 'CVE-\d{4}-\d{4,7}'
+    description: "CVE identifier pattern"
+```
+
+**config/fusion/similarity_concepts.yaml:**
+```yaml
+concepts:
+  - name: "reasoning"
+    keywords:
+      - "step by step"
+      - "solve this problem"
+      - "explain your reasoning"
+      - "break down the solution"
+    threshold: 0.75
+    aggregate_method: "mean"
+  
+  - name: "infrastructure"
+    keywords:
+      - "deploy kubernetes cluster"
+      - "configure infrastructure"
+      - "set up cloud resources"
+    threshold: 0.75
+    aggregate_method: "max"
+```
+
+**config/fusion/policy_rules.yaml:**
+```yaml
+rules:
+  # Safety blocks (Priority 200)
+  - name: "safety-pii-block"
+    condition: "regex.ssn.matched || regex.credit-card.matched"
+    action: "block"
+    priority: 200
+    message: "PII detected - request blocked for security"
+  
+  # High-confidence routing (Priority 150)
+  - name: "k8s-expert-routing"
+    condition: "keyword.kubernetes-infrastructure.matched && similarity.infrastructure.score > 0.8"
+    action: "route"
+    priority: 150
+    models: ["k8s-expert", "devops-specialist"]
+  
+  - name: "security-routing"
+    condition: "(keyword.security.matched || regex.cve-id.matched) && bert.category.value == 'computer science'"
+    action: "route"
+    priority: 150
+    models: ["security-hardened-model"]
+  
+  # Category boosting (Priority 100)
+  - name: "boost-reasoning-category"
+    condition: "similarity.reasoning.score > 0.75"
+    action: "boost_category"
+    priority: 100
+    category: "reasoning"
+    boost_weight: 1.5
+  
+  # Consensus routing (Priority 50)
+  - name: "multi-signal-consensus"
+    condition: "keyword.kubernetes-infrastructure.matched && similarity.infrastructure.score > 0.8 && bert.category.value == 'computer science'"
+    action: "route"
+    priority: 50
+    models: ["consensus-k8s-expert"]
+  
+  # Default fallthrough (Priority 0)
+  - name: "default-bert"
+    condition: "!regex.ssn.matched && !regex.credit-card.matched"
+    action: "fallthrough"
+    priority: 0
+```
+
+## Integration with Router
+
+### Step 1: Load Configuration
+
+Add config loading in your router initialization:
+
+```go
+import (
+    "github.com/vllm-project/semantic-router/src/semantic-router/pkg/config"
+    "github.com/vllm-project/semantic-router/src/semantic-router/pkg/utils/fusion"
+)
+
+// Load router configuration
+cfg, err := config.LoadConfig("config/config.yaml")
+if err != nil {
+    return err
+}
+
+// Initialize fusion engine if enabled
+var fusionEngine *fusion.Engine
+if cfg.ContentScanning.Enabled {
+    fusionEngine, err = initializeFusionEngine(cfg)
+    if err != nil {
+        return fmt.Errorf("failed to initialize fusion engine: %w", err)
+    }
+}
+```
+
+### Step 2: Initialize Fusion Engine
+
+```go
+func initializeFusionEngine(cfg *config.RouterConfig) (*fusion.Engine, error) {
+    // Convert config rules to fusion policy
+    policy := &fusion.Policy{
+        Rules: make([]fusion.Rule, 0, len(cfg.ContentScanning.FusionPolicy.Rules)),
+    }
+    
+    for _, cfgRule := range cfg.ContentScanning.FusionPolicy.Rules {
+        rule := fusion.Rule{
+            Name:        cfgRule.Name,
+            Condition:   cfgRule.Condition,
+            Action:      fusion.ActionType(cfgRule.Action),
+            Priority:    cfgRule.Priority,
+            Models:      cfgRule.Models,
+            Category:    cfgRule.Category,
+            BoostWeight: cfgRule.BoostWeight,
+            Message:     cfgRule.Message,
+        }
+        policy.Rules = append(policy.Rules, rule)
+    }
+    
+    // Create and return engine
+    return fusion.NewEngine(policy), nil
+}
+```
+
+### Step 3: Gather Signals
+
+```go
+func gatherSignals(query string, cfg *config.RouterConfig) (*fusion.SignalContext, error) {
+    ctx := fusion.NewSignalContext()
+    
+    // Gather keyword signals
+    if cfg.ContentScanning.Providers.Keyword.Enabled {
+        keywordSignals := detectKeywords(query, cfg.ContentScanning.Providers.Keyword.RulesPath)
+        for _, sig := range keywordSignals {
+            ctx.AddSignal(sig)
+        }
+    }
+    
+    // Gather regex signals
+    if cfg.ContentScanning.Providers.Regex.Enabled {
+        regexSignals := detectRegexPatterns(query, cfg.ContentScanning.Providers.Regex.PatternsPath)
+        for _, sig := range regexSignals {
+            ctx.AddSignal(sig)
+        }
+    }
+    
+    // Gather similarity signals
+    if cfg.ContentScanning.Providers.Similarity.Enabled {
+        similaritySignals := computeSimilarity(query, cfg.ContentScanning.Providers.Similarity.ConceptsPath)
+        for _, sig := range similaritySignals {
+            ctx.AddSignal(sig)
+        }
+    }
+    
+    // Add BERT classification signal (existing classifier)
+    bertResult := classifyWithBERT(query)
+    ctx.AddSignal(fusion.Signal{
+        Provider: "bert",
+        Name:     "category",
+        Value:    bertResult.Category,
+        Score:    bertResult.Confidence,
+        Matched:  bertResult.Confidence > cfg.Classifier.CategoryModel.Threshold,
+    })
+    
+    return ctx, nil
+}
+```
+
+### Step 4: Evaluate Policy and Route
+
+```go
+func routeRequest(query string, cfg *config.RouterConfig, engine *fusion.Engine) ([]string, error) {
+    // Gather all signals
+    signalCtx, err := gatherSignals(query, cfg)
+    if err != nil {
+        return nil, fmt.Errorf("failed to gather signals: %w", err)
+    }
+    
+    // Evaluate fusion policy
+    result, err := engine.Evaluate(signalCtx)
+    if err != nil {
+        return nil, fmt.Errorf("failed to evaluate fusion policy: %w", err)
+    }
+    
+    // Log decision if audit logging is enabled
+    if cfg.ContentScanning.AuditLogging {
+        logPolicyDecision(result, query)
+    }
+    
+    // Handle action
+    switch result.Action {
+    case fusion.ActionBlock:
+        return nil, fmt.Errorf("request blocked: %s", result.Message)
+    
+    case fusion.ActionRoute:
+        return result.Models, nil
+    
+    case fusion.ActionBoostCategory:
+        // Apply boost to BERT category weights
+        return routeWithBoost(query, result.Category, result.BoostWeight, cfg)
+    
+    case fusion.ActionFallthrough:
+        // Use standard BERT classification
+        return routeWithBERT(query, cfg)
+    
+    default:
+        return nil, fmt.Errorf("unknown action type: %s", result.Action)
+    }
+}
+```
+
+## Complete Examples
+
+### Example 1: Safety-First Configuration
+
+Prioritize blocking PII and security threats:
+
+```yaml
+content_scanning:
+  enabled: true
+  default_action: fallthrough
+  audit_logging: true
+  
+  providers:
+    regex:
+      enabled: true
+      patterns_path: "config/fusion/security_patterns.yaml"
+  
+  fusion_policy:
+    rules:
+      - name: "block-pii"
+        condition: "regex.ssn.matched || regex.credit-card.matched || regex.email.matched"
+        action: "block"
+        priority: 200
+        message: "PII detected"
+      
+      - name: "default"
+        condition: "!regex.ssn.matched"
+        action: "fallthrough"
+        priority: 0
+```
+
+### Example 2: Specialized Routing Configuration
+
+Route to expert models based on topic detection:
+
+```yaml
+content_scanning:
+  enabled: true
+  
+  providers:
+    keyword:
+      enabled: true
+      rules_path: "config/fusion/topic_keywords.yaml"
+    similarity:
+      enabled: true
+      concepts_path: "config/fusion/topic_concepts.yaml"
+  
+  fusion_policy:
+    rules:
+      - name: "kubernetes-expert"
+        condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.75"
+        action: "route"
+        priority: 150
+        models: ["k8s-expert-v1", "k8s-expert-v2"]
+      
+      - name: "database-expert"
+        condition: "keyword.database.matched && similarity.database.score > 0.8"
+        action: "route"
+        priority: 150
+        models: ["db-expert", "sql-specialist"]
+      
+      - name: "fallback"
+        condition: "keyword.kubernetes.matched == false"
+        action: "fallthrough"
+        priority: 0
+```
+
+### Example 3: Multi-Signal Consensus
+
+Require multiple signals to agree before routing:
+
+```yaml
+content_scanning:
+  enabled: true
+  
+  providers:
+    keyword:
+      enabled: true
+      rules_path: "config/fusion/keywords.yaml"
+    similarity:
+      enabled: true
+      concepts_path: "config/fusion/concepts.yaml"
+  
+  fusion_policy:
+    rules:
+      - name: "high-confidence-routing"
+        condition: "keyword.topic.matched && similarity.topic.score > 0.85 && bert.category.value == 'computer science'"
+        action: "route"
+        priority: 100
+        models: ["expert-model"]
+      
+      - name: "medium-confidence-boost"
+        condition: "keyword.topic.matched && similarity.topic.score > 0.7"
+        action: "boost_category"
+        priority: 50
+        category: "computer science"
+        boost_weight: 1.3
+      
+      - name: "default"
+        condition: "keyword.topic.matched == false"
+        action: "fallthrough"
+        priority: 0
+```
+
+## Testing Your Configuration
+
+Test your configuration with a simple script:
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/vllm-project/semantic-router/src/semantic-router/pkg/config"
+    "github.com/vllm-project/semantic-router/src/semantic-router/pkg/utils/fusion"
+)
+
+func main() {
+    // Load config
+    cfg, _ := config.LoadConfig("config/config.yaml")
+    
+    // Initialize engine
+    engine, _ := initializeFusionEngine(cfg)
+    
+    // Test with sample signals
+    ctx := fusion.NewSignalContext()
+    ctx.AddSignal(fusion.Signal{
+        Provider: "keyword",
+        Name:     "kubernetes",
+        Matched:  true,
+    })
+    ctx.AddSignal(fusion.Signal{
+        Provider: "similarity",
+        Name:     "infrastructure",
+        Score:    0.85,
+        Matched:  true,
+    })
+    
+    // Evaluate
+    result, _ := engine.Evaluate(ctx)
+    
+    fmt.Printf("Matched Rule: %s\n", result.MatchedRule)
+    fmt.Printf("Action: %s\n", result.Action)
+    if result.Action == fusion.ActionRoute {
+        fmt.Printf("Models: %v\n", result.Models)
+    }
+}
+```
+
+## Best Practices
+
+1. **Priority Levels**: Use consistent priority levels across your organization:
+   - 200: Safety blocks
+   - 150: High-confidence routing
+   - 100: Category boosting
+   - 50: Multi-signal consensus
+   - 0: Default fallthrough
+
+2. **Audit Logging**: Always enable audit logging in production to track policy decisions
+
+3. **Testing**: Test your policies with various inputs before deploying to production
+
+4. **Gradual Rollout**: Start with fallthrough actions and gradually add blocking/routing rules
+
+5. **Performance**: Keep expression complexity reasonable - simpler expressions evaluate faster
+
+6. **Documentation**: Document each rule's purpose and the business logic behind it
diff --git a/src/semantic-router/pkg/utils/fusion/README.md b/src/semantic-router/pkg/utils/fusion/README.md
new file mode 100644
index 00000000..6b8a57ed
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/README.md
@@ -0,0 +1,282 @@
+# Signal Fusion Engine
+
+The Signal Fusion Engine is a policy-driven decision-making system that combines multiple signals into actionable routing decisions. It provides configurable boolean expression parsing, priority-based rule evaluation, and short-circuit evaluation.
+
+## Features
+
+### 1. Boolean Expression Parser
+- Supports complex boolean logic: `&&` (AND), `||` (OR), `!` (NOT)
+- Handles comparisons: `==`, `!=`, `>`, `<`, `>=`, `<=`
+- Parentheses for grouping expressions
+- Signal references in format: `provider.name.field`
+
+### 2. Priority-Based Rule Evaluation
+- Rules are evaluated in priority order (highest first)
+- Priority levels (recommended):
+  - **200**: Safety blocks (SSN, credit cards, PII)
+  - **150**: High-confidence routing overrides (keyword + regex matches)
+  - **100**: Category boosting (embedding similarity signals)
+  - **50**: Consensus requirements (multiple signals must agree)
+  - **0**: Default fallthrough
+
+### 3. Short-Circuit Evaluation
+- First matching rule wins
+- No further evaluation after a match
+- Efficient for common cases
+
+### 4. Action Types
+- **block**: Immediately reject requests
+- **route**: Route to specific model candidates
+- **boost_category**: Apply weight multipliers to categories
+- **fallthrough**: Use default behavior (BERT classification)
+
+## Usage Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/vllm-project/semantic-router/src/semantic-router/pkg/utils/fusion"
+)
+
+func main() {
+    // Create a signal context
+    context := fusion.NewSignalContext()
+    
+    // Add signals from various providers
+    context.AddSignal(fusion.Signal{
+        Provider: "keyword",
+        Name:     "kubernetes",
+        Matched:  true,
+    })
+    
+    context.AddSignal(fusion.Signal{
+        Provider: "similarity",
+        Name:     "infrastructure",
+        Score:    0.85,
+        Matched:  true,
+    })
+    
+    // Define policy rules
+    policy := &fusion.Policy{
+        Rules: []fusion.Rule{
+            {
+                Name:      "safety-block",
+                Condition: "regex.ssn.matched || regex.credit-card.matched",
+                Action:    fusion.ActionBlock,
+                Priority:  200,
+                Message:   "PII detected - request blocked",
+            },
+            {
+                Name:      "k8s-routing",
+                Condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.75",
+                Action:    fusion.ActionRoute,
+                Priority:  150,
+                Models:    []string{"k8s-expert", "devops-model"},
+            },
+            {
+                Name:      "boost-reasoning",
+                Condition: "similarity.reasoning.score > 0.75",
+                Action:    fusion.ActionBoostCategory,
+                Priority:  100,
+                Category:  "reasoning",
+                BoostWeight: 1.5,
+            },
+        },
+    }
+    
+    // Create engine and evaluate
+    engine := fusion.NewEngine(policy)
+    result, err := engine.Evaluate(context)
+    
+    if err != nil {
+        fmt.Printf("Error: %v\n", err)
+        return
+    }
+    
+    // Handle result
+    if result.Matched {
+        fmt.Printf("Rule matched: %s\n", result.MatchedRule)
+        fmt.Printf("Action: %s\n", result.Action)
+        
+        switch result.Action {
+        case fusion.ActionBlock:
+            fmt.Printf("Blocked: %s\n", result.Message)
+        case fusion.ActionRoute:
+            fmt.Printf("Route to models: %v\n", result.Models)
+        case fusion.ActionBoostCategory:
+            fmt.Printf("Boost %s by %.2fx\n", result.Category, result.BoostWeight)
+        }
+    } else {
+        fmt.Println("No rules matched - fallthrough to default behavior")
+    }
+}
+```
+
+## Expression Syntax
+
+### Signal References
+Signals are referenced using the format: `provider.name.field`
+
+**Fields:**
+- `matched`: Boolean indicating if the signal matched
+- `score`: Numeric value (e.g., similarity score, confidence)
+- `value`: String value (e.g., category name)
+
+**Examples:**
+```
+keyword.kubernetes.matched
+similarity.reasoning.score
+bert.category.value
+```
+
+### Boolean Operators
+- `&&` (AND): Both conditions must be true
+- `||` (OR): At least one condition must be true
+- `!` (NOT): Negates the condition
+
+**Examples:**
+```
+keyword.kubernetes.matched && keyword.security.matched
+keyword.docker.matched || keyword.kubernetes.matched
+!regex.pii.matched
+```
+
+### Comparison Operators
+- `==`: Equal to
+- `!=`: Not equal to
+- `>`: Greater than
+- `<`: Less than
+- `>=`: Greater than or equal to
+- `<=`: Less than or equal to
+
+**Examples:**
+```
+similarity.reasoning.score > 0.75
+similarity.infrastructure.score >= 0.8
+bert.category.value == 'computer science'
+bert.confidence != 0.5
+```
+
+### Complex Expressions
+Combine operators and use parentheses for grouping:
+
+```
+keyword.kubernetes.matched && (similarity.infrastructure.score > 0.8 || regex.k8s-pattern.matched)
+(keyword.security.matched && bert.category.value == 'security') || similarity.security.score > 0.9
+!regex.pii.matched && (keyword.safe.matched || similarity.safe.score > 0.7)
+```
+
+## Policy Configuration
+
+A policy consists of multiple rules that are evaluated in priority order:
+
+```go
+policy := &fusion.Policy{
+    Rules: []fusion.Rule{
+        {
+            Name:      "unique-rule-identifier",
+            Condition: "boolean expression",
+            Action:    fusion.ActionType,
+            Priority:  100,
+            // Action-specific fields:
+            Models:      []string{"model1", "model2"},  // For ActionRoute
+            Category:    "category-name",                // For ActionBoostCategory
+            BoostWeight: 1.5,                            // For ActionBoostCategory
+            Message:     "Block message",                // For ActionBlock
+        },
+    },
+}
+```
+
+## Testing
+
+The package includes comprehensive unit tests using Ginkgo/Gomega:
+
+```bash
+cd src/semantic-router
+go test -v ./pkg/utils/fusion/
+```
+
+Test coverage includes:
+- Simple signal references
+- Boolean operators (AND, OR, NOT)
+- Comparison operators (==, !=, >, <, >=, <=)
+- Complex nested expressions
+- Priority-based evaluation
+- Short-circuit behavior
+- All action types
+- Edge cases and error handling
+
+## Architecture
+
+### Components
+
+1. **Types** (`types.go`)
+   - `Signal`: Represents a single signal from a provider
+   - `SignalContext`: Container for all available signals
+   - `Rule`: Defines a policy rule with condition and action
+   - `Policy`: Collection of rules
+   - `EvaluationResult`: Result of policy evaluation
+
+2. **Expression Evaluator** (`expression.go`)
+   - Tokenizes and parses boolean expressions
+   - Evaluates expressions against signal context
+   - Supports complex nested logic
+
+3. **Policy Engine** (`engine.go`)
+   - Manages policy rules
+   - Sorts rules by priority
+   - Implements short-circuit evaluation
+   - Returns first matching rule result
+
+### Design Principles
+
+- **Configurable**: All aspects are configurable through data structures
+- **Efficient**: Short-circuit evaluation and priority ordering minimize work
+- **Flexible**: Expression language supports complex routing logic
+- **Type-Safe**: Strong typing for actions and signals
+- **Tested**: Comprehensive test coverage
+
+## Integration with Semantic Router
+
+The Signal Fusion Engine is designed to integrate with the existing semantic router architecture:
+
+1. **Signal Providers** gather signals:
+   - Keyword matcher (in-tree)
+   - Regex scanner (in-tree)
+   - Embedding similarity (in-tree or MCP)
+   - BERT classifier (existing)
+
+2. **Signal Context** is built from provider results
+
+3. **Fusion Engine** evaluates policy against context
+
+4. **Routing Decision** is made based on evaluation result:
+   - Block: Reject request
+   - Route: Select specific models
+   - Boost: Adjust category weights for BERT
+   - Fallthrough: Use standard BERT classification
+
+## Performance Characteristics
+
+- **Expression Parsing**: O(n) where n = expression length
+- **Rule Evaluation**: O(r × e) where r = number of rules, e = expression complexity
+- **Short-Circuit**: Average case terminates after first match
+- **Priority Sorting**: One-time O(r log r) cost at engine creation
+
+Typical performance:
+- Simple expressions (1-2 conditions): < 100 microseconds
+- Complex expressions (5+ conditions): < 500 microseconds
+- Full policy evaluation (10 rules): < 1 millisecond
+
+## Future Enhancements
+
+Potential improvements for future versions:
+- Expression compilation/caching for repeated evaluations
+- Support for regular expressions in string comparisons
+- Mathematical operations in expressions (addition, subtraction, etc.)
+- Built-in functions (e.g., `contains()`, `matches()`)
+- Validation of expressions at policy load time
+- Metrics and observability integration
diff --git a/src/semantic-router/pkg/utils/fusion/engine.go b/src/semantic-router/pkg/utils/fusion/engine.go
new file mode 100644
index 00000000..059a384a
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/engine.go
@@ -0,0 +1,85 @@
+package fusion
+
+import (
+	"fmt"
+	"sort"
+)
+
+// Engine is the main signal fusion engine that evaluates policies
+type Engine struct {
+	policy *Policy
+}
+
+// NewEngine creates a new fusion engine with the given policy
+func NewEngine(policy *Policy) *Engine {
+	// Sort rules by priority (highest first) for efficient evaluation
+	sortedRules := make([]Rule, len(policy.Rules))
+	copy(sortedRules, policy.Rules)
+	sort.Slice(sortedRules, func(i, j int) bool {
+		return sortedRules[i].Priority > sortedRules[j].Priority
+	})
+
+	return &Engine{
+		policy: &Policy{Rules: sortedRules},
+	}
+}
+
+// Evaluate evaluates the policy against the given signal context
+// Returns the first matching rule result (short-circuit evaluation)
+func (e *Engine) Evaluate(context *SignalContext) (*EvaluationResult, error) {
+	if e.policy == nil || len(e.policy.Rules) == 0 {
+		return &EvaluationResult{
+			Matched: false,
+			Action:  ActionFallthrough,
+		}, nil
+	}
+
+	evaluator := NewExpressionEvaluator(context)
+
+	// Evaluate rules in priority order (short-circuit: first match wins)
+	for _, rule := range e.policy.Rules {
+		matched, err := evaluator.Evaluate(rule.Condition)
+		if err != nil {
+			return nil, fmt.Errorf("error evaluating rule %s: %w", rule.Name, err)
+		}
+
+		if matched {
+			// First matching rule wins
+			return &EvaluationResult{
+				Matched:     true,
+				MatchedRule: rule.Name,
+				Action:      rule.Action,
+				Models:      rule.Models,
+				Category:    rule.Category,
+				BoostWeight: rule.BoostWeight,
+				Message:     rule.Message,
+			}, nil
+		}
+	}
+
+	// No rules matched - fallthrough
+	return &EvaluationResult{
+		Matched: false,
+		Action:  ActionFallthrough,
+	}, nil
+}
+
+// NewSignalContext creates a new empty signal context
+func NewSignalContext() *SignalContext {
+	return &SignalContext{
+		Signals: make(map[string]Signal),
+	}
+}
+
+// AddSignal adds a signal to the context
+func (sc *SignalContext) AddSignal(signal Signal) {
+	key := signal.Provider + "." + signal.Name
+	sc.Signals[key] = signal
+}
+
+// GetSignal retrieves a signal from the context
+func (sc *SignalContext) GetSignal(provider, name string) (Signal, bool) {
+	key := provider + "." + name
+	signal, exists := sc.Signals[key]
+	return signal, exists
+}
diff --git a/src/semantic-router/pkg/utils/fusion/example_test.go b/src/semantic-router/pkg/utils/fusion/example_test.go
new file mode 100644
index 00000000..5be40dc0
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/example_test.go
@@ -0,0 +1,268 @@
+package fusion
+
+import (
+	"fmt"
+)
+
+// Example demonstrates basic Signal Fusion Engine usage
+func Example() {
+	// Create a signal context
+	context := NewSignalContext()
+
+	// Add signals from various providers
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "kubernetes",
+		Matched:  true,
+	})
+
+	context.AddSignal(Signal{
+		Provider: "similarity",
+		Name:     "infrastructure",
+		Score:    0.85,
+		Matched:  true,
+	})
+
+	// Define a simple policy
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:      "k8s-routing",
+				Condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.75",
+				Action:    ActionRoute,
+				Priority:  150,
+				Models:    []string{"k8s-expert", "devops-model"},
+			},
+		},
+	}
+
+	// Create engine and evaluate
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	if result.Matched {
+		fmt.Printf("Matched rule: %s\n", result.MatchedRule)
+		fmt.Printf("Action: %s\n", result.Action)
+		fmt.Printf("Models: %v\n", result.Models)
+	}
+
+	// Output:
+	// Matched rule: k8s-routing
+	// Action: route
+	// Models: [k8s-expert devops-model]
+}
+
+// Example_priorityEvaluation demonstrates priority-based rule evaluation
+func Example_priorityEvaluation() {
+	context := NewSignalContext()
+
+	// Add signals
+	context.AddSignal(Signal{
+		Provider: "regex",
+		Name:     "ssn",
+		Matched:  true,
+	})
+
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "kubernetes",
+		Matched:  true,
+	})
+
+	// Define policy with multiple priority levels
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:      "safety-block",
+				Condition: "regex.ssn.matched",
+				Action:    ActionBlock,
+				Priority:  200, // Highest priority
+				Message:   "PII detected - request blocked",
+			},
+			{
+				Name:      "k8s-routing",
+				Condition: "keyword.kubernetes.matched",
+				Action:    ActionRoute,
+				Priority:  150,
+				Models:    []string{"k8s-expert"},
+			},
+		},
+	}
+
+	// Safety block wins due to higher priority
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	fmt.Printf("Matched rule: %s (priority: 200)\n", result.MatchedRule)
+	fmt.Printf("Action: %s\n", result.Action)
+
+	// Output:
+	// Matched rule: safety-block (priority: 200)
+	// Action: block
+}
+
+// Example_complexExpressions demonstrates complex boolean expressions
+func Example_complexExpressions() {
+	context := NewSignalContext()
+
+	// Add multiple signals
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "kubernetes",
+		Matched:  true,
+	})
+
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "security",
+		Matched:  true,
+	})
+
+	context.AddSignal(Signal{
+		Provider: "similarity",
+		Name:     "infrastructure",
+		Score:    0.88,
+		Matched:  true,
+	})
+
+	context.AddSignal(Signal{
+		Provider: "bert",
+		Name:     "category",
+		Value:    "computer science",
+		Matched:  true,
+	})
+
+	// Complex policy requiring consensus from multiple signals
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:      "multi-signal-consensus",
+				Condition: "keyword.kubernetes.matched && keyword.security.matched && similarity.infrastructure.score > 0.8 && bert.category.value == 'computer science'",
+				Action:    ActionRoute,
+				Priority:  50,
+				Models:    []string{"k8s-security-expert"},
+			},
+		},
+	}
+
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	if result.Matched {
+		fmt.Printf("All signals agree - routing to: %v\n", result.Models)
+	}
+
+	// Output:
+	// All signals agree - routing to: [k8s-security-expert]
+}
+
+// Example_boostCategory demonstrates category boosting
+func Example_boostCategory() {
+	context := NewSignalContext()
+
+	context.AddSignal(Signal{
+		Provider: "similarity",
+		Name:     "reasoning",
+		Score:    0.82,
+		Matched:  true,
+	})
+
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:        "boost-reasoning",
+				Condition:   "similarity.reasoning.score > 0.75",
+				Action:      ActionBoostCategory,
+				Priority:    100,
+				Category:    "reasoning",
+				BoostWeight: 1.5,
+			},
+		},
+	}
+
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	if result.Matched {
+		fmt.Printf("Boost %s category by %.1fx\n", result.Category, result.BoostWeight)
+	}
+
+	// Output:
+	// Boost reasoning category by 1.5x
+}
+
+// Example_shortCircuit demonstrates short-circuit evaluation
+func Example_shortCircuit() {
+	context := NewSignalContext()
+
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "test",
+		Matched:  true,
+	})
+
+	// Multiple rules could match, but first one wins
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:      "first-rule",
+				Condition: "keyword.test.matched",
+				Action:    ActionRoute,
+				Priority:  100,
+				Models:    []string{"model-a"},
+			},
+			{
+				Name:      "second-rule",
+				Condition: "keyword.test.matched",
+				Action:    ActionRoute,
+				Priority:  50,
+				Models:    []string{"model-b"},
+			},
+		},
+	}
+
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	// Only first rule is evaluated and returned
+	fmt.Printf("Matched: %s\n", result.MatchedRule)
+	fmt.Printf("Models: %v\n", result.Models)
+
+	// Output:
+	// Matched: first-rule
+	// Models: [model-a]
+}
+
+// Example_fallthrough demonstrates fallthrough behavior
+func Example_fallthrough() {
+	context := NewSignalContext()
+
+	// No signals match
+	context.AddSignal(Signal{
+		Provider: "keyword",
+		Name:     "docker",
+		Matched:  false,
+	})
+
+	policy := &Policy{
+		Rules: []Rule{
+			{
+				Name:      "docker-routing",
+				Condition: "keyword.docker.matched",
+				Action:    ActionRoute,
+				Priority:  100,
+				Models:    []string{"docker-expert"},
+			},
+		},
+	}
+
+	engine := NewEngine(policy)
+	result, _ := engine.Evaluate(context)
+
+	if !result.Matched {
+		fmt.Printf("No rules matched - action: %s\n", result.Action)
+	}
+
+	// Output:
+	// No rules matched - action: fallthrough
+}
diff --git a/src/semantic-router/pkg/utils/fusion/expression.go b/src/semantic-router/pkg/utils/fusion/expression.go
new file mode 100644
index 00000000..3b8e6c56
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/expression.go
@@ -0,0 +1,407 @@
+package fusion
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// ExpressionEvaluator evaluates boolean expressions against a SignalContext
+type ExpressionEvaluator struct {
+	context *SignalContext
+}
+
+// NewExpressionEvaluator creates a new expression evaluator
+func NewExpressionEvaluator(context *SignalContext) *ExpressionEvaluator {
+	return &ExpressionEvaluator{context: context}
+}
+
+// Evaluate parses and evaluates a boolean expression
+// Supported operations:
+// - Boolean operators: && (AND), || (OR), ! (NOT)
+// - Comparisons: ==, !=, >, <, >=, <=
+// - Signal references: provider.name.field (e.g., "keyword.kubernetes.matched", "similarity.reasoning.score")
+func (e *ExpressionEvaluator) Evaluate(expression string) (bool, error) {
+	expression = strings.TrimSpace(expression)
+	if expression == "" {
+		return false, fmt.Errorf("empty expression")
+	}
+
+	// Parse and evaluate the expression
+	tokens, err := tokenize(expression)
+	if err != nil {
+		return false, err
+	}
+
+	return e.evaluateTokens(tokens)
+}
+
+// Token types
+type tokenType int
+
+const (
+	tokenIdentifier tokenType = iota
+	tokenNumber
+	tokenString
+	tokenOperator
+	tokenLeftParen
+	tokenRightParen
+)
+
+type token struct {
+	typ   tokenType
+	value string
+}
+
+// tokenize converts an expression string into tokens
+func tokenize(expression string) ([]token, error) {
+	var tokens []token
+	var current strings.Builder
+	inString := false
+	stringDelim := rune(0)
+
+	i := 0
+	for i < len(expression) {
+		ch := rune(expression[i])
+
+		// Handle string literals
+		if ch == '\'' || ch == '"' {
+			if !inString {
+				inString = true
+				stringDelim = ch
+				i++
+				continue
+			} else if ch == stringDelim {
+				tokens = append(tokens, token{typ: tokenString, value: current.String()})
+				current.Reset()
+				inString = false
+				stringDelim = 0
+				i++
+				continue
+			}
+		}
+
+		if inString {
+			current.WriteRune(ch)
+			i++
+			continue
+		}
+
+		// Skip whitespace
+		if unicode.IsSpace(ch) {
+			if current.Len() > 0 {
+				tokens = append(tokens, parseToken(current.String()))
+				current.Reset()
+			}
+			i++
+			continue
+		}
+
+		// Handle operators
+		if i+1 < len(expression) {
+			twoChar := expression[i : i+2]
+			if twoChar == "&&" || twoChar == "||" || twoChar == "==" || twoChar == "!=" || twoChar == ">=" || twoChar == "<=" {
+				if current.Len() > 0 {
+					tokens = append(tokens, parseToken(current.String()))
+					current.Reset()
+				}
+				tokens = append(tokens, token{typ: tokenOperator, value: twoChar})
+				i += 2
+				continue
+			}
+		}
+
+		// Handle single character operators
+		if ch == '>' || ch == '<' || ch == '!' {
+			if current.Len() > 0 {
+				tokens = append(tokens, parseToken(current.String()))
+				current.Reset()
+			}
+			tokens = append(tokens, token{typ: tokenOperator, value: string(ch)})
+			i++
+			continue
+		}
+
+		// Handle parentheses
+		if ch == '(' {
+			if current.Len() > 0 {
+				tokens = append(tokens, parseToken(current.String()))
+				current.Reset()
+			}
+			tokens = append(tokens, token{typ: tokenLeftParen, value: "("})
+			i++
+			continue
+		}
+
+		if ch == ')' {
+			if current.Len() > 0 {
+				tokens = append(tokens, parseToken(current.String()))
+				current.Reset()
+			}
+			tokens = append(tokens, token{typ: tokenRightParen, value: ")"})
+			i++
+			continue
+		}
+
+		current.WriteRune(ch)
+		i++
+	}
+
+	if inString {
+		return nil, fmt.Errorf("unterminated string literal")
+	}
+
+	if current.Len() > 0 {
+		tokens = append(tokens, parseToken(current.String()))
+	}
+
+	return tokens, nil
+}
+
+func parseToken(s string) token {
+	// Check if it's a number
+	if _, err := strconv.ParseFloat(s, 64); err == nil {
+		return token{typ: tokenNumber, value: s}
+	}
+	// Otherwise it's an identifier
+	return token{typ: tokenIdentifier, value: s}
+}
+
+// evaluateTokens evaluates a list of tokens
+func (e *ExpressionEvaluator) evaluateTokens(tokens []token) (bool, error) {
+	if len(tokens) == 0 {
+		return false, fmt.Errorf("no tokens to evaluate")
+	}
+
+	// Handle parentheses first (strip outer parentheses if present)
+	if len(tokens) > 0 && tokens[0].typ == tokenLeftParen && tokens[len(tokens)-1].typ == tokenRightParen {
+		// Check if these are matching outer parentheses
+		depth := 0
+		allMatching := true
+		for i := 0; i < len(tokens); i++ {
+			if tokens[i].typ == tokenLeftParen {
+				depth++
+			} else if tokens[i].typ == tokenRightParen {
+				depth--
+			}
+			// If depth goes to 0 before the end, these aren't outer parentheses
+			if depth == 0 && i < len(tokens)-1 {
+				allMatching = false
+				break
+			}
+		}
+		if allMatching {
+			return e.evaluateTokens(tokens[1 : len(tokens)-1])
+		}
+	}
+
+	// Handle OR operator (lowest precedence) - skip parentheses
+	depth := 0
+	for i := 0; i < len(tokens); i++ {
+		if tokens[i].typ == tokenLeftParen {
+			depth++
+		} else if tokens[i].typ == tokenRightParen {
+			depth--
+		} else if depth == 0 && tokens[i].typ == tokenOperator && tokens[i].value == "||" {
+			left, err := e.evaluateTokens(tokens[:i])
+			if err != nil {
+				return false, err
+			}
+			right, err := e.evaluateTokens(tokens[i+1:])
+			if err != nil {
+				return false, err
+			}
+			return left || right, nil
+		}
+	}
+
+	// Handle AND operator (higher precedence than OR) - skip parentheses
+	depth = 0
+	for i := 0; i < len(tokens); i++ {
+		if tokens[i].typ == tokenLeftParen {
+			depth++
+		} else if tokens[i].typ == tokenRightParen {
+			depth--
+		} else if depth == 0 && tokens[i].typ == tokenOperator && tokens[i].value == "&&" {
+			left, err := e.evaluateTokens(tokens[:i])
+			if err != nil {
+				return false, err
+			}
+			right, err := e.evaluateTokens(tokens[i+1:])
+			if err != nil {
+				return false, err
+			}
+			return left && right, nil
+		}
+	}
+
+	// Handle NOT operator
+	if len(tokens) > 0 && tokens[0].typ == tokenOperator && tokens[0].value == "!" {
+		result, err := e.evaluateTokens(tokens[1:])
+		if err != nil {
+			return false, err
+		}
+		return !result, nil
+	}
+
+	// Handle comparison operators - skip parentheses
+	depth = 0
+	for i := 0; i < len(tokens); i++ {
+		if tokens[i].typ == tokenLeftParen {
+			depth++
+		} else if tokens[i].typ == tokenRightParen {
+			depth--
+		} else if depth == 0 && tokens[i].typ == tokenOperator {
+			op := tokens[i].value
+			if op == "==" || op == "!=" || op == ">" || op == "<" || op == ">=" || op == "<=" {
+				if i == 0 || i == len(tokens)-1 {
+					return false, fmt.Errorf("invalid comparison expression")
+				}
+				return e.evaluateComparison(tokens[:i], op, tokens[i+1:])
+			}
+		}
+	}
+
+	// Handle single boolean value (signal reference)
+	if len(tokens) == 1 && tokens[0].typ == tokenIdentifier {
+		return e.evaluateSignalReference(tokens[0].value)
+	}
+
+	return false, fmt.Errorf("unable to evaluate expression")
+}
+
+// evaluateComparison evaluates a comparison between two values
+func (e *ExpressionEvaluator) evaluateComparison(leftTokens []token, op string, rightTokens []token) (bool, error) {
+	leftVal, err := e.getComparisonValue(leftTokens)
+	if err != nil {
+		return false, err
+	}
+
+	rightVal, err := e.getComparisonValue(rightTokens)
+	if err != nil {
+		return false, err
+	}
+
+	// Try numeric comparison first
+	leftNum, leftIsNum := leftVal.(float64)
+	rightNum, rightIsNum := rightVal.(float64)
+
+	if leftIsNum && rightIsNum {
+		switch op {
+		case "==":
+			return leftNum == rightNum, nil
+		case "!=":
+			return leftNum != rightNum, nil
+		case ">":
+			return leftNum > rightNum, nil
+		case "<":
+			return leftNum < rightNum, nil
+		case ">=":
+			return leftNum >= rightNum, nil
+		case "<=":
+			return leftNum <= rightNum, nil
+		}
+	}
+
+	// Fall back to string comparison
+	leftStr := fmt.Sprint(leftVal)
+	rightStr := fmt.Sprint(rightVal)
+
+	switch op {
+	case "==":
+		return leftStr == rightStr, nil
+	case "!=":
+		return leftStr != rightStr, nil
+	default:
+		return false, fmt.Errorf("operator %s not supported for string comparison", op)
+	}
+}
+
+// getComparisonValue extracts a value from tokens for comparison
+func (e *ExpressionEvaluator) getComparisonValue(tokens []token) (interface{}, error) {
+	if len(tokens) == 0 {
+		return nil, fmt.Errorf("empty comparison value")
+	}
+
+	if len(tokens) == 1 {
+		switch tokens[0].typ {
+		case tokenNumber:
+			return strconv.ParseFloat(tokens[0].value, 64)
+		case tokenString:
+			return tokens[0].value, nil
+		case tokenIdentifier:
+			return e.getSignalValue(tokens[0].value)
+		}
+	}
+
+	return nil, fmt.Errorf("complex comparison values not supported")
+}
+
+// evaluateSignalReference evaluates a signal reference as a boolean
+func (e *ExpressionEvaluator) evaluateSignalReference(ref string) (bool, error) {
+	val, err := e.getSignalValue(ref)
+	if err != nil {
+		return false, err
+	}
+
+	// Convert to boolean
+	if b, ok := val.(bool); ok {
+		return b, nil
+	}
+
+	// Treat non-zero numbers as true
+	if f, ok := val.(float64); ok {
+		return f != 0, nil
+	}
+
+	// Treat non-empty strings as true
+	if s, ok := val.(string); ok {
+		return s != "", nil
+	}
+
+	return false, fmt.Errorf("cannot convert signal value to boolean")
+}
+
+// getSignalValue retrieves a value from a signal reference
+// Format: provider.name.field (e.g., "keyword.kubernetes.matched", "similarity.reasoning.score")
+func (e *ExpressionEvaluator) getSignalValue(ref string) (interface{}, error) {
+	parts := strings.Split(ref, ".")
+	if len(parts) < 3 {
+		return nil, fmt.Errorf("invalid signal reference: %s (expected format: provider.name.field)", ref)
+	}
+
+	provider := parts[0]
+	name := parts[1]
+	field := parts[2]
+
+	// Create signal key
+	key := provider + "." + name
+
+	signal, exists := e.context.Signals[key]
+	if !exists {
+		// Signal not found - treat as false/zero
+		switch field {
+		case "matched":
+			return false, nil
+		case "score":
+			return 0.0, nil
+		case "value":
+			return "", nil
+		default:
+			return nil, fmt.Errorf("unknown field: %s", field)
+		}
+	}
+
+	// Extract the requested field
+	switch field {
+	case "matched":
+		return signal.Matched, nil
+	case "score":
+		return signal.Score, nil
+	case "value":
+		return signal.Value, nil
+	default:
+		return nil, fmt.Errorf("unknown field: %s", field)
+	}
+}
diff --git a/src/semantic-router/pkg/utils/fusion/fusion_test.go b/src/semantic-router/pkg/utils/fusion/fusion_test.go
new file mode 100644
index 00000000..c24b716d
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/fusion_test.go
@@ -0,0 +1,611 @@
+package fusion
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestFusion(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Signal Fusion Suite")
+}
+
+var _ = Describe("Signal Fusion Engine", func() {
+	Describe("Expression Evaluator", func() {
+		var (
+			context   *SignalContext
+			evaluator *ExpressionEvaluator
+		)
+
+		BeforeEach(func() {
+			context = NewSignalContext()
+			evaluator = NewExpressionEvaluator(context)
+		})
+
+		Context("when evaluating simple signal references", func() {
+			It("should return true for matched signals", func() {
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+
+				result, err := evaluator.Evaluate("keyword.kubernetes.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+			})
+
+			It("should return false for unmatched signals", func() {
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  false,
+				})
+
+				result, err := evaluator.Evaluate("keyword.kubernetes.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeFalse())
+			})
+
+			It("should return false for non-existent signals", func() {
+				result, err := evaluator.Evaluate("keyword.nonexistent.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeFalse())
+			})
+		})
+
+		Context("when evaluating boolean operators", func() {
+			BeforeEach(func() {
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "security",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "docker",
+					Matched:  false,
+				})
+			})
+
+			It("should evaluate AND correctly", func() {
+				result, err := evaluator.Evaluate("keyword.kubernetes.matched && keyword.security.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("keyword.kubernetes.matched && keyword.docker.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeFalse())
+			})
+
+			It("should evaluate OR correctly", func() {
+				result, err := evaluator.Evaluate("keyword.kubernetes.matched || keyword.docker.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("keyword.docker.matched || keyword.nonexistent.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeFalse())
+			})
+
+			It("should evaluate NOT correctly", func() {
+				result, err := evaluator.Evaluate("!keyword.docker.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("!keyword.kubernetes.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeFalse())
+			})
+
+			It("should handle complex boolean expressions", func() {
+				result, err := evaluator.Evaluate("keyword.kubernetes.matched && (keyword.security.matched || keyword.docker.matched)")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("(keyword.kubernetes.matched || keyword.docker.matched) && keyword.security.matched")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+			})
+		})
+
+		Context("when evaluating comparisons", func() {
+			BeforeEach(func() {
+				context.AddSignal(Signal{
+					Provider: "similarity",
+					Name:     "reasoning",
+					Score:    0.85,
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "bert",
+					Name:     "category",
+					Value:    "computer science",
+					Matched:  true,
+				})
+			})
+
+			It("should evaluate numeric comparisons", func() {
+				result, err := evaluator.Evaluate("similarity.reasoning.score > 0.75")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score >= 0.85")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score < 0.9")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score <= 0.85")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score == 0.85")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score != 0.75")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+			})
+
+			It("should evaluate string comparisons", func() {
+				result, err := evaluator.Evaluate("bert.category.value == 'computer science'")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("bert.category.value != 'biology'")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+			})
+
+			It("should combine comparisons with boolean operators", func() {
+				result, err := evaluator.Evaluate("similarity.reasoning.score > 0.75 && bert.category.value == 'computer science'")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+
+				result, err = evaluator.Evaluate("similarity.reasoning.score > 0.9 || bert.category.value == 'computer science'")
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result).To(BeTrue())
+			})
+		})
+
+		Context("when handling edge cases", func() {
+			It("should return error for empty expressions", func() {
+				_, err := evaluator.Evaluate("")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("empty expression"))
+			})
+
+			It("should return error for invalid expressions", func() {
+				_, err := evaluator.Evaluate("invalid expression &&")
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+
+	Describe("Policy Engine", func() {
+		var (
+			context *SignalContext
+		)
+
+		BeforeEach(func() {
+			context = NewSignalContext()
+		})
+
+		Context("when evaluating priority-based rules", func() {
+			It("should evaluate rules in priority order", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "low-priority",
+							Condition: "keyword.test.matched",
+							Action:    ActionRoute,
+							Priority:  10,
+							Models:    []string{"model-a"},
+						},
+						{
+							Name:      "high-priority",
+							Condition: "keyword.test.matched",
+							Action:    ActionBlock,
+							Priority:  100,
+							Message:   "Blocked by high priority rule",
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "test",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.MatchedRule).To(Equal("high-priority"))
+				Expect(result.Action).To(Equal(ActionBlock))
+				Expect(result.Message).To(Equal("Blocked by high priority rule"))
+			})
+
+			It("should sort rules by priority descending", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{Name: "rule1", Condition: "keyword.a.matched", Priority: 50},
+						{Name: "rule2", Condition: "keyword.b.matched", Priority: 200},
+						{Name: "rule3", Condition: "keyword.c.matched", Priority: 100},
+					},
+				}
+
+				engine := NewEngine(policy)
+
+				// Verify rules are sorted by priority
+				Expect(engine.policy.Rules[0].Name).To(Equal("rule2"))
+				Expect(engine.policy.Rules[0].Priority).To(Equal(200))
+				Expect(engine.policy.Rules[1].Name).To(Equal("rule3"))
+				Expect(engine.policy.Rules[1].Priority).To(Equal(100))
+				Expect(engine.policy.Rules[2].Name).To(Equal("rule1"))
+				Expect(engine.policy.Rules[2].Priority).To(Equal(50))
+			})
+		})
+
+		Context("when using short-circuit evaluation", func() {
+			It("should return first matching rule", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "first-match",
+							Condition: "keyword.kubernetes.matched",
+							Action:    ActionRoute,
+							Priority:  100,
+							Models:    []string{"k8s-expert"},
+						},
+						{
+							Name:      "second-match",
+							Condition: "keyword.kubernetes.matched",
+							Action:    ActionBlock,
+							Priority:  50,
+							Message:   "Should not reach here",
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.MatchedRule).To(Equal("first-match"))
+				Expect(result.Action).To(Equal(ActionRoute))
+				Expect(result.Models).To(Equal([]string{"k8s-expert"}))
+			})
+
+			It("should skip non-matching rules", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "no-match",
+							Condition: "keyword.docker.matched",
+							Action:    ActionBlock,
+							Priority:  200,
+						},
+						{
+							Name:      "match",
+							Condition: "keyword.kubernetes.matched",
+							Action:    ActionRoute,
+							Priority:  100,
+							Models:    []string{"k8s-expert"},
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "docker",
+					Matched:  false,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.MatchedRule).To(Equal("match"))
+			})
+		})
+
+		Context("when testing different action types", func() {
+			It("should handle block actions", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "block-rule",
+							Condition: "regex.ssn.matched",
+							Action:    ActionBlock,
+							Priority:  200,
+							Message:   "SSN detected",
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "regex",
+					Name:     "ssn",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.Action).To(Equal(ActionBlock))
+				Expect(result.Message).To(Equal("SSN detected"))
+			})
+
+			It("should handle route actions", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "route-rule",
+							Condition: "keyword.kubernetes.matched && keyword.security.matched",
+							Action:    ActionRoute,
+							Priority:  150,
+							Models:    []string{"k8s-security-expert", "devops-model"},
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "security",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.Action).To(Equal(ActionRoute))
+				Expect(result.Models).To(Equal([]string{"k8s-security-expert", "devops-model"}))
+			})
+
+			It("should handle boost_category actions", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:        "boost-rule",
+							Condition:   "similarity.reasoning.score > 0.75",
+							Action:      ActionBoostCategory,
+							Priority:    100,
+							Category:    "reasoning",
+							BoostWeight: 1.5,
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "similarity",
+					Name:     "reasoning",
+					Score:    0.85,
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.Action).To(Equal(ActionBoostCategory))
+				Expect(result.Category).To(Equal("reasoning"))
+				Expect(result.BoostWeight).To(Equal(1.5))
+			})
+
+			It("should handle fallthrough when no rules match", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "no-match",
+							Condition: "keyword.docker.matched",
+							Action:    ActionBlock,
+							Priority:  100,
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "docker",
+					Matched:  false,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeFalse())
+				Expect(result.Action).To(Equal(ActionFallthrough))
+			})
+		})
+
+		Context("when handling complex real-world scenarios", func() {
+			It("should handle multi-signal consensus requirements", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "consensus-route",
+							Condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.8 && bert.category.value == 'computer science'",
+							Action:    ActionRoute,
+							Priority:  50,
+							Models:    []string{"k8s-expert"},
+						},
+					},
+				}
+
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "similarity",
+					Name:     "infrastructure",
+					Score:    0.85,
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "bert",
+					Name:     "category",
+					Value:    "computer science",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.Action).To(Equal(ActionRoute))
+				Expect(result.Models).To(Equal([]string{"k8s-expert"}))
+			})
+
+			It("should prioritize safety blocks over routing", func() {
+				policy := &Policy{
+					Rules: []Rule{
+						{
+							Name:      "safety-block",
+							Condition: "regex.ssn.matched || regex.credit-card.matched",
+							Action:    ActionBlock,
+							Priority:  200,
+							Message:   "PII detected",
+						},
+						{
+							Name:      "route-to-model",
+							Condition: "keyword.kubernetes.matched",
+							Action:    ActionRoute,
+							Priority:  150,
+							Models:    []string{"k8s-expert"},
+						},
+					},
+				}
+
+				// Both rules would match
+				context.AddSignal(Signal{
+					Provider: "regex",
+					Name:     "ssn",
+					Matched:  true,
+				})
+				context.AddSignal(Signal{
+					Provider: "keyword",
+					Name:     "kubernetes",
+					Matched:  true,
+				})
+
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				// Safety block should win due to higher priority
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeTrue())
+				Expect(result.MatchedRule).To(Equal("safety-block"))
+				Expect(result.Action).To(Equal(ActionBlock))
+			})
+		})
+
+		Context("when handling empty policies", func() {
+			It("should return fallthrough for nil policy", func() {
+				engine := NewEngine(&Policy{})
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeFalse())
+				Expect(result.Action).To(Equal(ActionFallthrough))
+			})
+
+			It("should return fallthrough for empty rules", func() {
+				policy := &Policy{Rules: []Rule{}}
+				engine := NewEngine(policy)
+				result, err := engine.Evaluate(context)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(result.Matched).To(BeFalse())
+				Expect(result.Action).To(Equal(ActionFallthrough))
+			})
+		})
+	})
+
+	Describe("SignalContext", func() {
+		var context *SignalContext
+
+		BeforeEach(func() {
+			context = NewSignalContext()
+		})
+
+		It("should add and retrieve signals", func() {
+			signal := Signal{
+				Provider: "keyword",
+				Name:     "kubernetes",
+				Matched:  true,
+			}
+
+			context.AddSignal(signal)
+
+			retrieved, exists := context.GetSignal("keyword", "kubernetes")
+			Expect(exists).To(BeTrue())
+			Expect(retrieved.Matched).To(BeTrue())
+		})
+
+		It("should return false for non-existent signals", func() {
+			_, exists := context.GetSignal("keyword", "nonexistent")
+			Expect(exists).To(BeFalse())
+		})
+
+		It("should overwrite existing signals", func() {
+			signal1 := Signal{
+				Provider: "keyword",
+				Name:     "test",
+				Matched:  false,
+			}
+			signal2 := Signal{
+				Provider: "keyword",
+				Name:     "test",
+				Matched:  true,
+			}
+
+			context.AddSignal(signal1)
+			context.AddSignal(signal2)
+
+			retrieved, exists := context.GetSignal("keyword", "test")
+			Expect(exists).To(BeTrue())
+			Expect(retrieved.Matched).To(BeTrue())
+		})
+	})
+})
diff --git a/src/semantic-router/pkg/utils/fusion/integration_example_test.go b/src/semantic-router/pkg/utils/fusion/integration_example_test.go
new file mode 100644
index 00000000..3adb7eab
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/integration_example_test.go
@@ -0,0 +1,407 @@
+package fusion_test
+
+import (
+	"fmt"
+
+	"github.com/vllm-project/semantic-router/src/semantic-router/pkg/utils/fusion"
+)
+
+// This file demonstrates how to integrate the Signal Fusion Engine with the router
+
+// Example showing end-to-end integration with the router
+func Example_integration() {
+	// Step 1: Create a fusion policy from configuration
+	policy := &fusion.Policy{
+		Rules: []fusion.Rule{
+			{
+				Name:      "safety-block",
+				Condition: "regex.ssn.matched || regex.credit-card.matched",
+				Action:    fusion.ActionBlock,
+				Priority:  200,
+				Message:   "PII detected - request blocked",
+			},
+			{
+				Name:      "k8s-routing",
+				Condition: "keyword.kubernetes.matched && similarity.infrastructure.score > 0.75",
+				Action:    fusion.ActionRoute,
+				Priority:  150,
+				Models:    []string{"k8s-expert", "devops-model"},
+			},
+			{
+				Name:      "boost-reasoning",
+				Condition: "similarity.reasoning.score > 0.75",
+				Action:    fusion.ActionBoostCategory,
+				Priority:  100,
+				Category:  "reasoning",
+				BoostWeight: 1.5,
+			},
+			{
+				Name:      "default-fallthrough",
+				Condition: "!regex.ssn.matched",
+				Action:    fusion.ActionFallthrough,
+				Priority:  0,
+			},
+		},
+	}
+
+	// Step 2: Initialize the fusion engine
+	engine := fusion.NewEngine(policy)
+
+	// Step 3: Simulate gathering signals from various providers
+	// In real implementation, these would come from:
+	// - Keyword matcher scanning the query
+	// - Regex scanner looking for patterns
+	// - Embedding similarity comparing to concepts
+	// - BERT classifier categorizing the query
+
+	context := fusion.NewSignalContext()
+
+	// Keyword signal (from keyword matcher)
+	context.AddSignal(fusion.Signal{
+		Provider: "keyword",
+		Name:     "kubernetes",
+		Matched:  true,
+	})
+
+	// Similarity signal (from embedding similarity)
+	context.AddSignal(fusion.Signal{
+		Provider: "similarity",
+		Name:     "infrastructure",
+		Score:    0.85,
+		Matched:  true,
+	})
+
+	// Regex signal (from regex scanner)
+	context.AddSignal(fusion.Signal{
+		Provider: "regex",
+		Name:     "ssn",
+		Matched:  false,
+	})
+
+	// BERT signal (from existing classifier)
+	context.AddSignal(fusion.Signal{
+		Provider: "bert",
+		Name:     "category",
+		Value:    "computer science",
+		Score:    0.92,
+		Matched:  true,
+	})
+
+	// Step 4: Evaluate the policy
+	result, _ := engine.Evaluate(context)
+
+	// Step 5: Handle the result
+	fmt.Printf("Rule matched: %s\n", result.MatchedRule)
+	fmt.Printf("Action: %s\n", result.Action)
+	fmt.Printf("Route to models: %v\n", result.Models)
+
+	// Output:
+	// Rule matched: k8s-routing
+	// Action: route
+	// Route to models: [k8s-expert devops-model]
+}
+
+// Example showing how to handle different action types
+func Example_actionHandling() {
+	// Policy with various action types
+	policy := &fusion.Policy{
+		Rules: []fusion.Rule{
+			{
+				Name:      "block-rule",
+				Condition: "regex.pii.matched",
+				Action:    fusion.ActionBlock,
+				Priority:  200,
+				Message:   "Blocked due to PII",
+			},
+			{
+				Name:      "route-rule",
+				Condition: "keyword.topic.matched",
+				Action:    fusion.ActionRoute,
+				Priority:  150,
+				Models:    []string{"specialist-model"},
+			},
+			{
+				Name:      "boost-rule",
+				Condition: "similarity.concept.score > 0.8",
+				Action:    fusion.ActionBoostCategory,
+				Priority:  100,
+				Category:  "science",
+				BoostWeight: 1.5,
+			},
+			{
+				Name:      "fallthrough-rule",
+				Condition: "!regex.pii.matched",
+				Action:    fusion.ActionFallthrough,
+				Priority:  0,
+			},
+		},
+	}
+
+	engine := fusion.NewEngine(policy)
+
+	// Test Case 1: Block action
+	fmt.Println("=== Test Case 1: Block Action ===")
+	ctx1 := fusion.NewSignalContext()
+	ctx1.AddSignal(fusion.Signal{
+		Provider: "regex",
+		Name:     "pii",
+		Matched:  true,
+	})
+
+	result1, _ := engine.Evaluate(ctx1)
+	if result1.Action == fusion.ActionBlock {
+		fmt.Printf("Blocked: %s\n", result1.Message)
+	}
+
+	// Test Case 2: Route action
+	fmt.Println("\n=== Test Case 2: Route Action ===")
+	ctx2 := fusion.NewSignalContext()
+	ctx2.AddSignal(fusion.Signal{
+		Provider: "keyword",
+		Name:     "topic",
+		Matched:  true,
+	})
+	ctx2.AddSignal(fusion.Signal{
+		Provider: "regex",
+		Name:     "pii",
+		Matched:  false,
+	})
+
+	result2, _ := engine.Evaluate(ctx2)
+	if result2.Action == fusion.ActionRoute {
+		fmt.Printf("Route to: %v\n", result2.Models)
+	}
+
+	// Test Case 3: Boost action
+	fmt.Println("\n=== Test Case 3: Boost Action ===")
+	ctx3 := fusion.NewSignalContext()
+	ctx3.AddSignal(fusion.Signal{
+		Provider: "similarity",
+		Name:     "concept",
+		Score:    0.85,
+		Matched:  true,
+	})
+	ctx3.AddSignal(fusion.Signal{
+		Provider: "regex",
+		Name:     "pii",
+		Matched:  false,
+	})
+
+	result3, _ := engine.Evaluate(ctx3)
+	if result3.Action == fusion.ActionBoostCategory {
+		fmt.Printf("Boost %s by %.1fx\n", result3.Category, result3.BoostWeight)
+	}
+
+	// Test Case 4: Fallthrough action
+	fmt.Println("\n=== Test Case 4: Fallthrough Action ===")
+	ctx4 := fusion.NewSignalContext()
+	ctx4.AddSignal(fusion.Signal{
+		Provider: "regex",
+		Name:     "pii",
+		Matched:  false,
+	})
+
+	result4, _ := engine.Evaluate(ctx4)
+	if result4.Action == fusion.ActionFallthrough {
+		fmt.Println("Fallthrough to BERT classification")
+	}
+
+	// Output:
+	// === Test Case 1: Block Action ===
+	// Blocked: Blocked due to PII
+	//
+	// === Test Case 2: Route Action ===
+	// Route to: [specialist-model]
+	//
+	// === Test Case 3: Boost Action ===
+	// Boost science by 1.5x
+	//
+	// === Test Case 4: Fallthrough Action ===
+	// Fallthrough to BERT classification
+}
+
+// Example showing how to load policy from configuration struct
+func Example_policyFromConfig() {
+	// Simulate loading from YAML config
+	// In real implementation, this would be unmarshaled from config.yaml
+	type ConfigRule struct {
+		Name        string
+		Condition   string
+		Action      string
+		Priority    int
+		Models      []string
+		Category    string
+		BoostWeight float64
+		Message     string
+	}
+
+	configRules := []ConfigRule{
+		{
+			Name:      "safety-check",
+			Condition: "regex.ssn.matched",
+			Action:    "block",
+			Priority:  200,
+			Message:   "SSN detected",
+		},
+		{
+			Name:      "expert-routing",
+			Condition: "keyword.kubernetes.matched && similarity.infra.score > 0.8",
+			Action:    "route",
+			Priority:  150,
+			Models:    []string{"k8s-expert"},
+		},
+	}
+
+	// Convert config rules to fusion rules
+	policy := &fusion.Policy{
+		Rules: make([]fusion.Rule, 0, len(configRules)),
+	}
+
+	for _, cfgRule := range configRules {
+		rule := fusion.Rule{
+			Name:        cfgRule.Name,
+			Condition:   cfgRule.Condition,
+			Action:      fusion.ActionType(cfgRule.Action),
+			Priority:    cfgRule.Priority,
+			Models:      cfgRule.Models,
+			Category:    cfgRule.Category,
+			BoostWeight: cfgRule.BoostWeight,
+			Message:     cfgRule.Message,
+		}
+		policy.Rules = append(policy.Rules, rule)
+	}
+
+	// Create engine
+	engine := fusion.NewEngine(policy)
+
+	// Test it
+	ctx := fusion.NewSignalContext()
+	ctx.AddSignal(fusion.Signal{
+		Provider: "keyword",
+		Name:     "kubernetes",
+		Matched:  true,
+	})
+	ctx.AddSignal(fusion.Signal{
+		Provider: "similarity",
+		Name:     "infra",
+		Score:    0.85,
+		Matched:  true,
+	})
+
+	result, _ := engine.Evaluate(ctx)
+	fmt.Printf("Matched: %s\n", result.MatchedRule)
+	fmt.Printf("Models: %v\n", result.Models)
+
+	// Output:
+	// Matched: expert-routing
+	// Models: [k8s-expert]
+}
+
+// Example showing signal provider integration
+func Example_signalProviders() {
+	// This shows how different providers contribute signals
+
+	// Simulated provider functions (in real implementation, these would be actual providers)
+	detectKeywords := func(query string) []fusion.Signal {
+		// Keyword matcher scans query for configured keywords
+		return []fusion.Signal{
+			{
+				Provider: "keyword",
+				Name:     "kubernetes",
+				Matched:  true, // Found "kubernetes" in query
+			},
+			{
+				Provider: "keyword",
+				Name:     "security",
+				Matched:  true, // Found "security" in query
+			},
+		}
+	}
+
+	scanRegex := func(query string) []fusion.Signal {
+		// Regex scanner looks for patterns
+		return []fusion.Signal{
+			{
+				Provider: "regex",
+				Name:     "ssn",
+				Matched:  false, // No SSN pattern found
+			},
+			{
+				Provider: "regex",
+				Name:     "cve-id",
+				Matched:  true, // Found CVE pattern
+			},
+		}
+	}
+
+	computeSimilarity := func(query string) []fusion.Signal {
+		// Embedding similarity compares to concepts
+		return []fusion.Signal{
+			{
+				Provider: "similarity",
+				Name:     "infrastructure",
+				Score:    0.87,
+				Matched:  true,
+			},
+			{
+				Provider: "similarity",
+				Name:     "security",
+				Score:    0.82,
+				Matched:  true,
+			},
+		}
+	}
+
+	classifyBERT := func(query string) fusion.Signal {
+		// BERT classifier (existing)
+		return fusion.Signal{
+			Provider: "bert",
+			Name:     "category",
+			Value:    "computer science",
+			Score:    0.91,
+			Matched:  true,
+		}
+	}
+
+	// Gather all signals for a query
+	query := "How to secure a Kubernetes cluster against CVE-2024-1234?"
+
+	ctx := fusion.NewSignalContext()
+
+	// Add signals from all providers
+	for _, sig := range detectKeywords(query) {
+		ctx.AddSignal(sig)
+	}
+	for _, sig := range scanRegex(query) {
+		ctx.AddSignal(sig)
+	}
+	for _, sig := range computeSimilarity(query) {
+		ctx.AddSignal(sig)
+	}
+	ctx.AddSignal(classifyBERT(query))
+
+	// Now evaluate with a policy
+	policy := &fusion.Policy{
+		Rules: []fusion.Rule{
+			{
+				Name:      "security-k8s-expert",
+				Condition: "keyword.kubernetes.matched && keyword.security.matched && regex.cve-id.matched",
+				Action:    fusion.ActionRoute,
+				Priority:  150,
+				Models:    []string{"k8s-security-expert"},
+			},
+		},
+	}
+
+	engine := fusion.NewEngine(policy)
+	result, _ := engine.Evaluate(ctx)
+
+	fmt.Printf("Query: %s\n", query)
+	fmt.Printf("Matched rule: %s\n", result.MatchedRule)
+	fmt.Printf("Route to: %v\n", result.Models)
+
+	// Output:
+	// Query: How to secure a Kubernetes cluster against CVE-2024-1234?
+	// Matched rule: security-k8s-expert
+	// Route to: [k8s-security-expert]
+}
diff --git a/src/semantic-router/pkg/utils/fusion/types.go b/src/semantic-router/pkg/utils/fusion/types.go
new file mode 100644
index 00000000..199ae0d4
--- /dev/null
+++ b/src/semantic-router/pkg/utils/fusion/types.go
@@ -0,0 +1,74 @@
+package fusion
+
+// ActionType represents the type of action to take when a rule matches
+type ActionType string
+
+const (
+	ActionBlock         ActionType = "block"
+	ActionRoute         ActionType = "route"
+	ActionBoostCategory ActionType = "boost_category"
+	ActionFallthrough   ActionType = "fallthrough"
+)
+
+// Signal represents a single signal result from a provider
+type Signal struct {
+	// Provider is the source of the signal (e.g., "keyword", "regex", "similarity", "bert")
+	Provider string
+	// Name is the specific signal identifier (e.g., rule name, pattern name)
+	Name string
+	// Matched indicates if the signal matched
+	Matched bool
+	// Score is an optional numeric value (e.g., similarity score, confidence)
+	Score float64
+	// Value is an optional string value (e.g., category name)
+	Value string
+}
+
+// SignalContext holds all available signals for evaluation
+type SignalContext struct {
+	Signals map[string]Signal
+}
+
+// Rule represents a fusion policy rule
+type Rule struct {
+	// Name is a unique identifier for the rule
+	Name string
+	// Condition is the boolean expression to evaluate
+	Condition string
+	// Action specifies what to do when the condition matches
+	Action ActionType
+	// Priority determines evaluation order (higher = evaluated first)
+	Priority int
+	// Models is the list of target models for route actions
+	Models []string
+	// Category is the target category for boost actions
+	Category string
+	// BoostWeight is the multiplier for boost actions
+	BoostWeight float64
+	// Message is the response message for block actions
+	Message string
+}
+
+// Policy represents a complete fusion policy with multiple rules
+type Policy struct {
+	// Rules are evaluated in priority order
+	Rules []Rule
+}
+
+// EvaluationResult represents the result of evaluating a policy
+type EvaluationResult struct {
+	// Matched indicates if any rule matched
+	Matched bool
+	// MatchedRule is the name of the first matching rule (if any)
+	MatchedRule string
+	// Action is the action to take
+	Action ActionType
+	// Models is the list of candidate models for route actions
+	Models []string
+	// Category is the target category for boost actions
+	Category string
+	// BoostWeight is the multiplier for boost actions
+	BoostWeight float64
+	// Message is the response message for block actions
+	Message string
+}