AI-First Startup Architecture: Building Intelligent Products from Day One

The startup landscape has fundamentally shifted. While previous generations of companies retrofitted AI capabilities onto existing products, today's most successful startups are building intelligence into their core architecture from the very beginning. This AI-first approach isn't just about adding machine learning features—it's about designing systems where artificial intelligence becomes as fundamental as databases, APIs, and user authentication.

The difference between AI-first and AI-later approaches extends far beyond implementation timelines. AI-later companies often struggle with retrofitting intelligent capabilities onto rigid architectures, leading to suboptimal performance, higher costs, and maintenance nightmares. In contrast, AI-first startups design their entire technology stack to support intelligent features from day one, creating competitive advantages that compound over time.

Consider how Notion approached their AI writing assistant versus how older document platforms have struggled to integrate similar capabilities. Notion's architecture was designed to handle dynamic content generation and real-time collaboration, making their AI integration feel native and performant. Legacy platforms often bolt on AI features that feel disconnected and slow, precisely because their underlying architecture wasn't designed for intelligent operations.

The AI-First Mindset: Why Architecture Matters from Day One

The fundamental difference between AI-first and AI-later approaches lies in architectural philosophy. AI-first companies treat machine learning models as first-class citizens in their system design, equivalent to databases, message queues, and external APIs. This means designing data flows, service architectures, and user experiences that anticipate and accommodate intelligent capabilities from the initial codebase.

AI-first architecture rests on three core pillars: intelligent data flows, seamless model integration, and scalable inference. Intelligent data flows capture user interactions and system events in formats that immediately support both operational needs and machine learning pipelines. Rather than extracting features from transactional data as an afterthought, AI-first systems structure data collection to serve dual purposes from day one.

The second pillar, seamless model integration, involves designing service architectures where AI models integrate as naturally as any other system component. This means establishing consistent interfaces, error handling patterns, and monitoring approaches that treat AI services with the same operational rigor as core business logic.

Scalable inference represents the third pillar, focusing on infrastructure patterns that can grow from prototype to production scale without fundamental rewrites. This includes designing for various model deployment patterns, implementing efficient caching strategies, and building cost management into the architecture from the beginning.

When mapping existing startup product patterns to AI enhancement opportunities, consider common workflows like user onboarding, content creation, search and discovery, and customer support. Each of these areas presents natural integration points for intelligent capabilities when the underlying architecture supports them.

The decision framework for building, buying, or integrating AI capabilities depends on several factors: core business differentiation, available talent, time-to-market requirements, and long-term strategic control. Build custom AI when it represents core product differentiation and you have the expertise. Buy existing solutions for commodity AI functions like image recognition or language translation. Integrate through APIs when you need specific capabilities but want to maintain architectural flexibility.

// AI service integration with error handling and fallback strategies
interface AIServiceConfig {
  primaryEndpoint: string;
  fallbackEndpoint?: string;
  timeout: number;
  maxRetries: number;
  fallbackStrategy: 'static' | 'cached' | 'simplified';
}

class AIService {
  private config: AIServiceConfig;
  private cache = new Map<string, { data: any; timestamp: number }>();
  
  constructor(config: AIServiceConfig) {
    this.config = config;
  }
  
  async processRequest(input: any, context: string): Promise<any> {
    const cacheKey = this.generateCacheKey(input, context);
    
    try {
      // Try primary AI service
      const result = await this.callAIEndpoint(this.config.primaryEndpoint, input);
      this.cache.set(cacheKey, { data: result, timestamp: Date.now() });
      return result;
    } catch (primaryError) {
      console.warn('Primary AI service failed:', primaryError.message);
      
      // Attempt fallback service
      if (this.config.fallbackEndpoint) {
        try {
          const fallbackResult = await this.callAIEndpoint(this.config.fallbackEndpoint, input);
          return fallbackResult;
        } catch (fallbackError) {
          console.error('Fallback AI service failed:', fallbackError.message);
        }
      }
      
      // Apply fallback strategy
      return this.applyFallbackStrategy(cacheKey, input);
    }
  }
  
  private async callAIEndpoint(endpoint: string, input: any): Promise<any> {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
    
    try {
      const response = await fetch(endpoint, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(input),
        signal: controller.signal
      });
      
      if (!response.ok) {
        throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } finally {
      clearTimeout(timeoutId);
    }
  }
  
  private applyFallbackStrategy(cacheKey: string, input: any): any {
    switch (this.config.fallbackStrategy) {
      case 'cached':
        const cached = this.cache.get(cacheKey);
        if (cached && Date.now() - cached.timestamp < 86400000) { // 24 hours
          return cached.data;
        }
        return this.getStaticFallback(input);
      
      case 'simplified':
        return this.getSimplifiedResponse(input);
      
      default:
        return this.getStaticFallback(input);
    }
  }
  
  private generateCacheKey(input: any, context: string): string {
    return `${context}:${JSON.stringify(input)}`;
  }
  
  private getStaticFallback(input: any): any {
    return { error: 'AI service unavailable', fallback: true };
  }
  
  private getSimplifiedResponse(input: any): any {
    // Implement rule-based fallback logic
    return { simplified: true, result: input };
  }
}

Data Architecture for Intelligent Applications

Data architecture forms the foundation of any AI-first system, requiring careful design of how information flows through your application. Event-driven data pipelines capture user interactions as they happen, creating rich datasets for both immediate operational needs and future machine learning applications.

The key insight is designing schemas that serve dual purposes: supporting transactional operations while simultaneously providing clean inputs for machine learning pipelines. Traditional startup databases optimize for operational efficiency, often creating normalized structures that complicate feature extraction. AI-first architectures balance normalization with denormalized views specifically designed for ML workflows.

Real-time feature stores represent a crucial component of intelligent applications, providing consistent model inputs across different services and deployment environments. Modern implementations leverage Redis, Apache Kafka, and stream processing frameworks to maintain low-latency access to computed features while handling the computational complexity of feature engineering.

// Real-time feature store implementation using Redis and event streaming
interface FeatureConfig {
  name: string;
  type: 'real_time' | 'batch' | 'streaming';
  ttl: number;
  dependencies: string[];
}

class FeatureStore {
  private redis: any; // Redis client
  private eventBus: any; // Event streaming client
  private features: Map<string, FeatureConfig> = new Map();
  
  constructor(redisClient: any, eventBusClient: any) {
    this.redis = redisClient;
    this.eventBus = eventBusClient;
    this.setupEventListeners();
  }
  
  registerFeature(config: FeatureConfig): void {
    this.features.set(config.name, config);
    console.log(`Registered feature: ${config.name}`);
  }
  
  async computeUserFeatures(userId: string, featureNames: string[]): Promise<Record<string, any>> {
    const features: Record<string, any> = {};
    const cacheKeys = featureNames.map(name => `user:${userId}:feature:${name}`);
    
    try {
      // Attempt to get cached features
      const cached = await this.redis.mget(cacheKeys);
      
      for (let i = 0; i < featureNames.length; i++) {
        const featureName = featureNames[i];
        const cachedValue = cached[i];
        
        if (cachedValue) {
          features[featureName] = JSON.parse(cachedValue);
        } else {
          // Compute missing feature
          features[featureName] = await this.computeFeature(userId, featureName);
          
          // Cache the computed feature
          const config = this.features.get(featureName);
          if (config) {
            await this.redis.setex(
              `user:${userId}:feature:${featureName}`,
              config.ttl,
              JSON.stringify(features[featureName])
            );
          }
        }
      }
      
      return features;
    } catch (error) {
      console.error('Error computing user features:', error);
      throw new Error('Feature computation failed');
    }
  }
  
  private async computeFeature(userId: string, featureName: string): Promise<any> {
    const config = this.features.get(featureName);
    if (!config) {
      throw new Error(`Unknown feature: ${featureName}`);
    }
    
    // Get dependency features if needed
    const dependencies: Record<string, any> = {};
    if (config.dependencies.length > 0) {
      const depFeatures = await this.computeUserFeatures(userId, config.dependencies);
      Object.assign(dependencies, depFeatures);
    }
    
    // Implement feature-specific computation logic
    switch (featureName) {
      case 'session_activity_score':
        return this.computeActivityScore(userId);
      case 'content_engagement_rate':
        return this.computeEngagementRate(userId, dependencies);
      default:
        throw new Error(`No computation logic for feature: ${featureName}`);
    }
  }
  
  private setupEventListeners(): void {
    this.eventBus.on('user_action', async (event: any) => {
      try {
        await this.invalidateAffectedFeatures(event.userId, event.actionType);
        await this.updateStreamingFeatures(event);
      } catch (error) {
        console.error('Error processing user action event:', error);
      }
    });
  }
  
  private async invalidateAffectedFeatures(userId: string, actionType: string): Promise<void> {
    const affectedFeatures = this.getAffectedFeatures(actionType);
    const keysToDelete = affectedFeatures.map(name => `user:${userId}:feature:${name}`);
    
    if (keysToDelete.length > 0) {
      await this.redis.del(...keysToDelete);
    }
  }
  
  private async updateStreamingFeatures(event: any): Promise<void> {
    // Update real-time aggregations
    const streamingFeatures = Array.from(this.features.entries())
      .filter(([_, config]) => config.type === 'streaming')
      .map(([name, _]) => name);
    
    for (const featureName of streamingFeatures) {
      await this.incrementalUpdateFeature(event.userId, featureName, event);
    }
  }
  
  private async computeActivityScore(userId: string): Promise<number> {
    // Implement activity score computation
    return Math.random() * 100; // Placeholder
  }
  
  private async computeEngagementRate(userId: string, dependencies: Record<string, any>): Promise<number> {
    // Implement engagement rate computation using dependencies
    return Math.random(); // Placeholder
  }
  
  private getAffectedFeatures(actionType: string): string[] {
    // Return features that should be invalidated for this action type
    const actionFeatureMap: Record<string, string[]> = {
      'page_view': ['session_activity_score', 'content_engagement_rate'],
      'button_click': ['user_interaction_frequency'],
      'content_share': ['content_engagement_rate', 'social_activity_score']
    };
    
    return actionFeatureMap[actionType] || [];
  }
  
  private async incrementalUpdateFeature(userId: string, featureName: string, event: any): Promise<void> {
    // Implement incremental updates for streaming features
    console.log(`Incrementally updating ${featureName} for user ${userId}`);
  }
}

Data versioning and lineage tracking become critical as your startup grows and model requirements evolve. Implementing these capabilities from early iterations prevents the technical debt that often accumulates when companies try to add traceability after the fact. Modern approaches use tools like DVC (Data Version Control) or Apache Atlas to maintain data lineage, but simpler solutions using metadata tables and event logging can be effective for early-stage startups.

Feedback loops that automatically capture model performance data represent another crucial component. These systems monitor model predictions against actual outcomes, capturing performance metrics, identifying drift, and feeding information back into retraining pipelines. The key is building these feedback mechanisms into your application logic rather than treating them as separate monitoring systems.

Model Integration Patterns for Startup Scale

Choosing the right model integration pattern depends on your specific latency, cost, and control requirements. Embedded models provide the lowest latency and highest reliability but require more sophisticated deployment processes. API-based inference offers simplicity and scalability but introduces network dependencies and ongoing costs. Hybrid approaches combine both patterns, using embedded models for critical paths and API services for complex processing.

Model versioning and A/B testing infrastructure enable continuous improvement of AI capabilities. This requires building systems that can route different user segments to different model versions while tracking performance metrics across each variant. The infrastructure should support gradual rollouts, automatic rollbacks, and statistical significance testing.

// Model A/B testing framework with automated performance tracking
interface ModelVariant {
  id: string;
  version: string;
  endpoint: string;
  trafficPercentage: number;
  enabled: boolean;
  metadata: Record<string, any>;
}

interface ExperimentConfig {
  name: string;
  variants: ModelVariant[];
  metrics: string[];
  minimumSampleSize: number;
  maxDuration: number;
}

class ModelABTestingFramework {
  private experiments: Map<string, ExperimentConfig> = new Map();
  private metrics: Map<string, any[]> = new Map();
  private userAssignments: Map<string, string> = new Map();
  
  createExperiment(config: ExperimentConfig): void {
    // Validate configuration
    const totalTraffic = config.variants.reduce((sum, v) => sum + v.trafficPercentage, 0);
    if (Math.abs(totalTraffic - 100) > 0.01) {
      throw new Error('Traffic percentages must sum to 100%');
    }
    
    this.experiments.set(config.name, config);
    this.metrics.set(config.name, []);
    console.log(`Created experiment: ${config.name}`);
  }
  
  async getModelForUser(experimentName: string, userId: string): Promise<string> {
    const experiment = this.experiments.get(experimentName);
    if (!experiment) {
      throw new Error(`Experiment not found: ${experimentName}`);
    }
    
    // Check if user already assigned to a variant
    const assignmentKey = `${experimentName}:${userId}`;
    let assignedVariant = this.userAssignments.get(assignmentKey);
    
    if (!assignedVariant) {
      // Assign user to variant based on traffic allocation
      assignedVariant = this.assignUserToVariant(userId, experiment.variants);
      this.userAssignments.set(assignmentKey, assignedVariant);
    }
    
    return assignedVariant;
  }
  
  async recordMetric(experimentName: string, userId: string, metricName: string, value: any): Promise<void> {
    const experiment = this.experiments.get(experimentName);
    if (!experiment || !experiment.metrics.includes(metricName)) {
      return;
    }
    
    const variant = await this.getModelForUser(experimentName, userId);
    const metrics = this.metrics.get(experimentName) || [];
    
    metrics.push({
      timestamp: Date.now(),
      userId,
      variant,
      metric: metricName,
      value,
    });
    
    this.metrics.set(experimentName, metrics);
    
    // Check if experiment should be evaluated
    await this.evaluateExperiment(experimentName);
  }
  
  private assignUserToVariant(userId: string, variants: ModelVariant[]): string {
    // Use consistent hashing for stable assignments
    const hash = this.hashString(userId) % 100;
    let cumulative = 0;
    
    for (const variant of variants) {
      if (!variant.enabled) continue;
      
      cumulative += variant.trafficPercentage;
      if (hash < cumulative) {
        return variant.id;
      }
    }
    
    // Fallback to first enabled variant
    const fallback = variants.find(v => v.enabled);
    return fallback?.id || variants[0].id;
  }
  
  private async evaluateExperiment(experimentName: string): Promise<void> {
    const experiment = this.experiments.get(experimentName);
    const metrics = this.metrics.get(experimentName);
    
    if (!experiment || !metrics || metrics.length < experiment.minimumSampleSize) {
      return;
    }
    
    // Group metrics by variant
    const variantMetrics = new Map<string, any[]>();
    metrics.forEach(metric => {
      if (!variantMetrics.has(metric.variant)) {
        variantMetrics.set(metric.variant, []);
      }
      variantMetrics.get(metric.variant)!.push(metric);
    });
    
    // Calculate statistical significance for each metric
    const results: Record<string, any> = {};
    
    for (const metricName of experiment.metrics) {
      results[metricName] = this.calculateSignificance(variantMetrics, metricName);
    }
    
    // Check for winning variant
    const winner = this.determineWinner(results);
    if (winner) {
      console.log(`Experiment ${experimentName} has a winner: ${winner}`);
      await this.promoteWinningVariant(experimentName, winner);
    }
  }
  
  private calculateSignificance(variantMetrics: Map<string, any[]>, metricName: string): any {
    // Implement statistical significance testing
    const variantStats = new Map();
    
    variantMetrics.forEach((metrics, variant) => {
      const relevantMetrics = metrics.filter(m => m.metric === metricName);
      if (relevantMetrics.length === 0) return;
      
      const values = relevantMetrics.map(m => m.value);
      const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
      const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
      
      variantStats.set(variant, {
        count: values.length,
        mean,
        variance,
        standardDeviation: Math.sqrt(variance)
      });
    });
    
    return Object.fromEntries(variantStats);
  }
  
  private determineWinner(results: Record<string, any>): string | null {
    // Implement winner determination logic based on statistical significance
    // This is a simplified example
    return null;
  }
  
  private async promoteWinningVariant(experimentName: string, winningVariantId: string): Promise<void> {
    // Implement logic to promote the winning variant to production
    console.log(`Promoting variant ${winningVariantId} for experiment ${experimentName}`);
  }
  
  private hashString(str: string): number {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }
}

Graceful degradation strategies ensure your application remains functional when AI services are unavailable. This involves implementing fallback mechanisms that provide simplified functionality, cached responses, or rule-based alternatives when machine learning models fail. The key is designing these fallbacks to be seamless from the user perspective while maintaining core application functionality.

Frontend Intelligence: Bringing AI to User Interfaces

Frontend AI integration requires careful consideration of user experience, performance, and progressive enhancement. Real-time recommendation engines must balance personalization with page load times, often requiring sophisticated caching strategies and precomputation of likely recommendations.

Mobile applications present unique opportunities and challenges for AI integration. On-device models provide privacy and performance benefits but require careful resource management and model optimization.

// Android ML Kit integration for offline AI capabilities
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.text.TextRecognition
import com.google.mlkit.vision.text.latin.TextRecognizerOptions
import kotlinx.coroutines.*
import java.io.File

class MLModelManager(private val context: Context) {
    private val textRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
    private val modelCache = LruCache<String, Any>(10)
    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    
    data class ModelResult(
        val success: Boolean,
        val data: Any? = null,
        val error: String? = null,
        val confidence: Float = 0f
    )
    
    suspend fun processImageWithText(imageUri: Uri): ModelResult = withContext(Dispatchers.IO) {
        try {
            val image = InputImage.fromFilePath(context, imageUri)
            val result = textRecognizer.process(image).await()
            
            val extractedText = result.textBlocks.joinToString("\n") { block ->
                block.text
            }
            
            // Cache the result for potential reuse
            modelCache.put(imageUri.toString(), extractedText)
            
            ModelResult(
                success = true,
                data = extractedText,
                confidence = calculateConfidence(result.textBlocks)
            )
        } catch (e: Exception) {
            ModelResult(
                success = false,
                error = e.message ?: "Unknown error occurred"
            )
        }
    }
    
    suspend fun batchProcessImages(imageUris: List<Uri>): List<ModelResult> = withContext(Dispatchers.IO) {
        val jobs = imageUris.map { uri ->
            async { processImageWithText(uri) }
        }
        jobs.awaitAll()
    }
    
    private fun calculateConfidence(textBlocks: List<com.google.mlkit.vision.text.Text.TextBlock>): Float {
        if (textBlocks.isEmpty()) return 0f
        
        val confidenceScores = textBlocks.mapNotNull { block ->
            // ML Kit doesn't directly provide confidence, so we estimate based on text characteristics
            val hasMultipleWords = block.text.split(" ").size > 1
            val hasAlphanumeric = block.text.matches(Regex(".*[a-zA-Z0-9].*"))
            val lengthScore = minOf(block.text.length / 10f, 1f)
            
            when {
                hasMultipleWords && hasAlphanumeric -> 0.9f + lengthScore * 0.1f
                hasAlphanumeric -> 0.7f + lengthScore * 0.2f
                else -> 0.5f
            }
        }
        
        return confidenceScores.average().toFloat()
    }
    
    suspend fun preloadModels() = withContext(Dispatchers.IO) {
        try {
            // Warm up the text recognizer
            val dummyBitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
            val dummyImage = InputImage.fromBitmap(dummyBitmap, 0)
            textRecognizer.process(dummyImage).await()
            
            Log.d("MLModelManager", "Models preloaded successfully")
        } catch (e: Exception) {
            Log.e("MLModelManager", "Failed to preload models", e)
        }
    }
    
    fun clearCache() {
        modelCache.evictAll()
    }
    
    fun getCacheSize(): Int = modelCache.size()
    
    fun cleanup() {
        scope.cancel()
        textRecognizer.close()
        clearCache()
    }
}

// Extension function to convert Task to suspend function
suspend fun <T> com.google.android.gms.tasks.Task<T>.await(): T {
    return suspendCancellableCoroutine { cont ->
        addOnCompleteListener { task ->
            if (task.exception != null) {
                cont.resumeWithException(task.exception!!)
            } else {
                cont.resume(task.result)
            }
        }
    }
}

iOS applications can leverage CoreML for sophisticated on-device inference while maintaining smooth user experiences through careful background processing and state management.

// CoreML model integration with background processing and cache management
import CoreML
import Foundation
import Combine

class CoreMLManager: ObservableObject {
    @Published var isProcessing = false
    @Published var lastResult: ModelResult?
    
    private var model: MLModel?
    private let processingQueue = DispatchQueue(label: "com.app.coreml", qos: .userInitiated)
    private let cacheManager = ModelCacheManager()
    private var cancellables = Set<AnyCancellable>()
    
    struct ModelResult {
        let predictions: [String: Double]
        let confidence: Double
        let processingTime: TimeInterval
        let fromCache: Bool
    }
    
    init() {
        loadModel()
        setupBackgroundProcessing()
    }
    
    private func loadModel() {
        processingQueue.async { [weak self] in
            do {
                // Replace with your actual model
                guard let modelURL = Bundle.main.url(forResource: "YourModel", withExtension: "mlmodelc") else {
                    print("Model file not found")
                    return
                }
                
                self?.model = try MLModel(contentsOf: modelURL)
                
                DispatchQueue.main.async {
                    print("CoreML model loaded successfully")
                }
            } catch {
                DispatchQueue.main.async {
                    print("Failed to load CoreML model: \(error)")
                }
            }
        }
    }
    
    func processInput(_ input: [String: Any]) -> AnyPublisher<ModelResult, Error> {
        return Future<ModelResult, Error> { [weak self] promise in
            guard let self = self else {
                promise(.failure(CoreMLError.managerDeallocated))
                return
            }
            
            // Check cache first
            let cacheKey = self.generateCacheKey(input)
            if let cachedResult = self.cacheManager.getCachedResult(for: cacheKey) {
                promise(.success(cachedResult))
                return
            }
            
            DispatchQueue.main.async {
                self.isProcessing = true
            }
            
            self.processingQueue.async {
                let startTime = CFAbsoluteTimeGetCurrent()
                
                do {
                    guard let model = self.model else {
                        throw CoreMLError.modelNotLoaded
                    }
                    
                    // Convert input to MLFeatureProvider
                    let provider = try MLDictionaryFeatureProvider(dictionary: input)
                    
                    // Make prediction
                    let output = try model.prediction(from: provider)
                    
                    // Process output
                    let predictions = self.extractPredictions(from: output)
                    let confidence = self.calculateConfidence(predictions)
                    let processingTime = CFAbsoluteTimeGetCurrent() - startTime
                    
                    let result = ModelResult(
                        predictions: predictions,
                        confidence: confidence,
                        processingTime: processingTime,
                        fromCache: false
                    )
                    
                    // Cache the result
                    self.cacheManager.cacheResult(result, for: cacheKey)
                    
                    DispatchQueue.main.async {
                        self.isProcessing = false
                        self.lastResult = result
                        promise(.success(result))
                    }
                    
                } catch {
                    DispatchQueue.main.async {
                        self.isProcessing = false
                        promise(.failure(error))
                    }
                }
            }
        }
        .eraseToAnyPublisher()
    }
    
    func batchProcess(_ inputs: [[String: Any]]) -> AnyPublisher<[ModelResult], Error> {
        let publishers = inputs.map { input in
            processInput(input)
        }
        
        return Publishers.MergeMany(publishers)
            .collect()
            .eraseToAnyPublisher()
    }
    
    private func extractPredictions(from output: MLFeatureProvider) -> [String: Double] {
        var predictions: [String: Double] = [:]
        
        for featureName in output.featureNames {
            if let featureValue = output.featureValue(for: featureName) {
                switch featureValue.type {
                case .double:
                    predictions[featureName] = featureValue.doubleValue
                case .multiArray:
                    // Handle multi-array outputs (e.g., classification probabilities)
                    if let array = featureValue.multiArrayValue {
                        for i in 0..<array.count {
                            predictions["\(featureName)_\(i)"] = array[i].doubleValue
                        }
                    }
                default:
                    break
                }
            }
        }
        
        return predictions
    }
    
    private func calculateConfidence(_ predictions: [String: Double]) -> Double {
        guard !predictions.isEmpty else { return 0.0 }
        
        let values = Array(predictions.values)
        let maxValue = values.max() ?? 0.0
        let sum = values.reduce(0, +)
        
        // Calculate confidence based on the ratio of max prediction to sum
        return sum > 0 ? maxValue / sum : 0.0
    }
    
    private func generateCacheKey(_ input: [String: Any]) -> String {
        let sortedKeys = input.keys.sorted()
        let keyValuePairs = sortedKeys.compactMap { key in
            if let value = input[key] {
                return "\(key):\(value)"
            }
            return nil
        }
        return keyValuePairs.joined(separator: "|")
    }
    
    private func setupBackgroundProcessing() {
        NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)
            .sink { [weak self] _ in
                self?.cacheManager.persistCache()
            }
            .store(in: &cancellables)
        
        NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)
            .sink { [weak self] _ in
                self?.cacheManager.loadPersistedCache()
            }
            .store(in: &cancellables)
    }
}

class ModelCacheManager {
    private var cache: [String: CoreMLManager.ModelResult] = [:]
    private let maxCacheSize = 100
    private let cache