9 AI Agent Implementations That Actually Work in E-commerce Codebases at Scale

# ai-cart-refactor-workflow.yml
name: Cart Refactoring Agent
on:
  workflow_dispatch:
    inputs:
      refactor_scope:
        description: 'Services to analyze'
        required: true
        default: 'cart-service,inventory-service,pricing-engine'

jobs:
  analyze-cart-flow:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Map Cart State Flow
        run: |
          # Agent analyzes complete cart lifecycle
          augment analyze-flow \
            --entry-points "src/cart/add-item.ts,src/cart/update-quantity.ts" \
            --trace-dependencies \
            --include-services "${{ github.event.inputs.refactor_scope }}" \
            --output cart-flow-analysis.json

      - name: Generate Refactoring Plan
        run: |
          augment refactor-plan \
            --flow-analysis cart-flow-analysis.json \
            --preserve-business-rules \
            --target-consistency "eventual-with-recovery" \
            --output refactor-plan.json

      - name: Execute Multi-Service Refactor
        run: |
          augment execute-refactor \
            --plan refactor-plan.json \
            --generate-tests \
            --validate-state-transitions \
            --create-pr

// payment-circuit-breaker.ts - Generated by AI agent
import { CircuitBreaker } from 'opossum';
import { PaymentGateway, PaymentRequest, PaymentResult } from './types';

class PaymentFailoverOrchestrator {
  private gateways: Map<string, PaymentGateway> = new Map();
  private circuitBreakers: Map<string, CircuitBreaker> = new Map();

  constructor(gateways: PaymentGateway[]) {
    gateways.forEach(gateway => {
      this.gateways.set(gateway.name, gateway);

      // Circuit breaker with e-commerce specific configuration
      const breaker = new CircuitBreaker(gateway.processPayment, {
        timeout: 30000,           // 30s timeout for payment processing
        errorThresholdPercentage: 10,  // Open circuit at 10% failure rate
        resetTimeout: 60000,      // Try recovery after 1 minute
        volumeThreshold: 5        // Need 5 requests before evaluating
      });

      breaker.fallback(() => this.routeToBackupGateway(gateway.name));

      breaker.on('open', () => {
        console.error(`Circuit breaker opened for ${gateway.name}`);
        this.alertGatewayFailure(gateway.name);
      });

      this.circuitBreakers.set(gateway.name, breaker);
    });
  }

  async processPayment(request: PaymentRequest): Promise<PaymentResult> {
    const primaryGateway = this.getPrimaryGateway();
    const breaker = this.circuitBreakers.get(primaryGateway);

    try {
      return await breaker.fire(request);
    } catch (error) {
      throw new Error('All payment gateways failed');
    }
  }

  private async routeToBackupGateway(failedGateway: string): Promise<PaymentResult> {
    const backupGateways = Array.from(this.gateways.keys())
      .filter(name => name !== failedGateway)
      .filter(name => this.circuitBreakers.get(name)?.isOpen === false);

    if (backupGateways.length === 0) {
      throw new Error('No healthy payment gateways available');
    }

    const backupGateway = this.gateways.get(backupGateways[0]);
    return await backupGateway.processPayment(request);
  }
}

// inventory-sync-agent.ts
import { InventorySource, InventoryUpdate, SyncStrategy } from './types';

class InventorySyncAgent {
  private sources: Map<string, InventorySource> = new Map();
  private syncInterval: number = 60000; // 1 minute

  constructor(sources: InventorySource[], strategy: SyncStrategy = 'warehouse-authoritative') {
    sources.forEach(source => this.sources.set(source.name, source));
    this.startSyncLoop();
  }

  async reconcileInventory(sku: string): Promise<void> {
    const inventoryLevels = await Promise.all(
      Array.from(this.sources.values()).map(async source => ({
        source: source.name,
        quantity: await source.getInventory(sku),
        timestamp: Date.now()
      }))
    );

    // Detect discrepancies
    const quantities = inventoryLevels.map(level => level.quantity);
    const hasDiscrepancy = new Set(quantities).size > 1;

    if (hasDiscrepancy) {
      // Apply conflict resolution
      const authoritativeLevel = this.resolveConflict(inventoryLevels);
      
      // Propagate correction to all sources
      await Promise.all(
        Array.from(this.sources.values())
          .filter(source => source.name !== authoritativeLevel.source)
          .map(source => 
            source.updateInventory(sku, authoritativeLevel.quantity)
          )
      );

      this.logReconciliation(sku, inventoryLevels, authoritativeLevel);
    }
  }

  private resolveConflict(levels: InventoryLevel[]): InventoryLevel {
    // Strategy: Warehouse management system is authoritative
    const wmsLevel = levels.find(l => l.source === 'warehouse-management');
    return wmsLevel || levels[0];
  }

  private async startSyncLoop(): Promise<void> {
    setInterval(async () => {
      const allSkus = await this.getAllSkus();
      for (const sku of allSkus) {
        await this.reconcileInventory(sku);
      }
    }, this.syncInterval);
  }
}

# fraud-detection-agent.py
from typing import Dict, List
import numpy as np
from sklearn.ensemble import RandomForestClassifier

class FraudDetectionAgent:
    def __init__(self):
        self.model = self.load_trained_model()
        self.risk_threshold = 0.75  # 75% probability triggers review
        
    def analyze_transaction(self, order: Dict) -> Dict:
        features = self.extract_features(order)
        risk_score = self.model.predict_proba([features])[0][1]
        
        return {
            'order_id': order['id'],
            'risk_score': risk_score,
            'decision': 'review' if risk_score > self.risk_threshold else 'approve',
            'signals': self.explain_risk_factors(features, risk_score)
        }
    
    def extract_features(self, order: Dict) -> List[float]:
        return [
            self.shipping_billing_mismatch(order),
            self.order_velocity_last_hour(order['user_id']),
            self.unusual_cart_composition(order['items']),
            self.new_account_high_value(order),
            self.international_shipping_domestic_card(order),
            self.order_value_zscore(order['total']),
            len(order['items']),
            order['total']
        ]
    
    def explain_risk_factors(self, features: List[float], risk_score: float) -> List[str]:
        signals = []
        if features[0] > 0.5:
            signals.append('Shipping and billing addresses do not match')
        if features[1] > 3:
            signals.append(f'High order velocity: {int(features[1])} orders in last hour')
        if features[2] > 0.7:
            signals.append('Unusual product combination detected')
        if features[3] > 0.8:
            signals.append('New account with high-value purchase')
        
        return signals

# Integration with order processing
def process_order_with_fraud_check(order: Dict) -> Dict:
    agent = FraudDetectionAgent()
    fraud_analysis = agent.analyze_transaction(order)
    
    if fraud_analysis['decision'] == 'review':
        # Hold order for manual review
        send_to_fraud_queue(order, fraud_analysis)
        return {'status': 'pending_review', 'analysis': fraud_analysis}
    else:
        # Process order normally
        fulfill_order(order)
        return {'status': 'approved', 'analysis': fraud_analysis}

// dynamic-pricing-agent.ts
interface PricingRule {
  minMargin: number;
  maxDiscount: number;
  competitorThreshold: number;
  inventoryAgeThreshold: number;
}

class DynamicPricingAgent {
  private rules: PricingRule;
  private competitorPrices: Map<string, number> = new Map();

  constructor(rules: PricingRule) {
    this.rules = rules;
  }

  async calculateOptimalPrice(
    sku: string,
    currentPrice: number,
    cost: number,
    inventory: number,
    inventoryAge: number
  ): Promise<number> {
    // Gather market data
    const competitorPrice = await this.getLowestCompetitorPrice(sku);
    const demandScore = await this.estimateDemand(sku);
    
    let optimalPrice = currentPrice;

    // Rule 1: Match competitor if they're significantly lower
    if (competitorPrice && competitorPrice < currentPrice * (1 - this.rules.competitorThreshold)) {
      optimalPrice = Math.max(competitorPrice, cost * (1 + this.rules.minMargin));
    }

    // Rule 2: Increase price for low inventory + high demand
    if (inventory < 10 && demandScore > 0.7) {
      optimalPrice = Math.min(currentPrice * 1.15, competitorPrice * 1.05);
    }

    // Rule 3: Discount aging inventory
    if (inventoryAge > this.rules.inventoryAgeThreshold) {
      const discountMultiplier = 1 - (this.rules.maxDiscount * (inventoryAge / 365));
      optimalPrice = Math.max(currentPrice * discountMultiplier, cost * (1 + this.rules.minMargin));
    }

    // Ensure minimum margin
    return Math.max(optimalPrice, cost * (1 + this.rules.minMargin));
  }

  async getLowestCompetitorPrice(sku: string): Promise<number | null> {
    const prices = await this.scrapeCompetitorPrices(sku);
    return prices.length > 0 ? Math.min(...prices) : null;
  }

  async estimateDemand(sku: string): Promise<number> {
    const recentViews = await this.getPageViews(sku, 7);
    const recentSales = await this.getSales(sku, 7);
    const conversionRate = recentSales / Math.max(recentViews, 1);
    return Math.min(conversionRate * 10, 1); // Normalize to 0-1
  }
}

# seo-content-agent.py
from typing import Dict, List

class SEOContentAgent:
    def __init__(self, brand_voice: str):
        self.brand_voice = brand_voice
        
    def generate_product_description(
        self,
        product: Dict,
        category: str,
        target_keywords: List[str]
    ) -> Dict[str, str]:
        # Extract product attributes
        attributes = self.extract_key_attributes(product)
        
        # Analyze competitor content
        competitor_patterns = self.analyze_top_ranking_pages(
            product['name'],
            category
        )
        
        # Generate optimized description
        description = self.compose_description(
            product,
            attributes,
            target_keywords,
            competitor_patterns
        )
        
        # Generate meta tags
        meta_title = self.generate_meta_title(product, target_keywords[0])
        meta_description = self.generate_meta_description(description)
        
        # Generate structured data
        structured_data = self.generate_structured_data(product, description)
        
        return {
            'description': description,
            'meta_title': meta_title,
            'meta_description': meta_description,
            'structured_data': structured_data
        }
    
    def compose_description(
        self,
        product: Dict,
        attributes: List[str],
        keywords: List[str],
        patterns: Dict
    ) -> str:
        # Opening hook with primary keyword
        opening = f"{product['name']} {keywords[0]} delivers {attributes[0]}."
        
        # Feature bullets incorporating keywords naturally
        features = []
        for attr, keyword in zip(attributes[1:4], keywords[1:]):
            features.append(f"{keyword.capitalize()} {attr}")
        
        # Benefits paragraph
        benefits = f"Perfect for {patterns['use_cases']}, this {product['category']} {patterns['benefit_phrase']}."
        
        # Closing with CTA
        closing = f"Order your {product['name']} today for {product['price']}."
        
        return f"{opening} {' '.join(features)}. {benefits} {closing}"

// cart-recovery-agent.ts
interface AbandonedCart {
  userId: string;
  cartId: string;
  items: CartItem[];
  totalValue: number;
  abandonedAt: Date;
  pageAtAbandonment: string;
}

class CartRecoveryAgent {
  async analyzeAbandonment(cart: AbandonedCart): Promise<string> {
    // Determine abandonment reason
    if (cart.pageAtAbandonment === 'shipping') {
      return 'shipping_cost';
    }
    if (cart.pageAtAbandonment === 'payment' && await this.hadPaymentFailure(cart)) {
      return 'payment_failure';
    }
    if (cart.totalValue > await this.getAverageOrderValue(cart.userId)) {
      return 'high_value_hesitation';
    }
    if (await this.isWindowShopper(cart.userId)) {
      return 'browsing';
    }
    return 'distracted';
  }

  async scheduleRecoverySequence(cart: AbandonedCart): Promise<void> {
    const abandonmentReason = await this.analyzeAbandonment(cart);
    const userTimezone = await this.getUserTimezone(cart.userId);
    
    const sequences = {
      'shipping_cost': [
        { delay: 60, template: 'free_shipping_offer', discount: 'FREE_SHIP' },
        { delay: 1440, template: 'cart_reminder', discount: null },
        { delay: 4320, template: 'last_chance', discount: 'SHIP10' }
      ],
      'high_value_hesitation': [
        { delay: 120, template: 'social_proof', discount: null },
        { delay: 1440, template: 'payment_plans', discount: null },
        { delay: 4320, template: 'limited_discount', discount: 'SAVE10' }
      ],
      'payment_failure': [
        { delay: 30, template: 'payment_support', discount: null },
        { delay: 180, template: 'alternative_payment', discount: null }
      ],
      'distracted': [
        { delay: 180, template: 'gentle_reminder', discount: null },
        { delay: 1440, template: 'urgency', discount: null },
        { delay: 4320, template: 'final_offer', discount: 'COMEBACK15' }
      ]
    };

    const sequence = sequences[abandonmentReason] || sequences['distracted'];
    
    for (const step of sequence) {
      await this.scheduleEmail(
        cart.userId,
        step.template,
        cart,
        this.calculateSendTime(step.delay, userTimezone),
        step.discount
      );
    }
  }

  private calculateSendTime(delayMinutes: number, timezone: string): Date {
    // Send during business hours in user's timezone (9am-6pm)
    const sendTime = new Date(Date.now() + delayMinutes * 60000);
    const hour = sendTime.getHours();
    
    if (hour < 9) {
      sendTime.setHours(9, 0, 0);
    } else if (hour > 18) {
      sendTime.setDate(sendTime.getDate() + 1);
      sendTime.setHours(9, 0, 0);
    }
    
    return sendTime;
  }
}

# return-fraud-agent.py
from typing import Dict, List

class ReturnFraudAgent:
    def __init__(self):
        self.fraud_threshold = 0.7
        
    def analyze_return_request(self, return_request: Dict) -> Dict:
        customer = return_request['customer']
        order = return_request['order']
        
        risk_signals = []
        risk_score = 0.0
        
        # Signal 1: High return rate
        return_rate = self.calculate_return_rate(customer['id'])
        if return_rate > 0.5:
            risk_score += 0.3
            risk_signals.append(f'Return rate {return_rate:.1%} exceeds normal threshold')
        
        # Signal 2: Wardrobing pattern
        if self.detect_wardrobing(order, return_request):
            risk_score += 0.4
            risk_signals.append('Wardrobing pattern detected: late return after typical usage period')
        
        # Signal 3: Serial returner with expensive items
        if return_rate > 0.4 and order['value'] > 500:
            risk_score += 0.2
            risk_signals.append('High-value item return from frequent returner')
        
        # Signal 4: Different item returned
        if return_request['reason'] == 'defective':
            risk_score += 0.1
            risk_signals.append('Defect claims require inspection')
        
        return {
            'return_id': return_request['id'],
            'risk_score': min(risk_score, 1.0),
            'decision': 'inspect' if risk_score > self.fraud_threshold else 'approve',
            'signals': risk_signals
        }
    
    def detect_wardrobing(self, order: Dict, return_request: Dict) -> bool:
        # Returns made just before return window expires
        days_since_delivery = (return_request['date'] - order['delivered_at']).days
        return_window = 30
        
        # Clothing/accessories returned 25-30 days after delivery
        if (order['category'] in ['clothing', 'accessories'] and 
            days_since_delivery > 25 and days_since_delivery <= return_window):
            return True
        
        return False
    
    def calculate_return_rate(self, customer_id: str) -> float:
        orders = self.get_customer_orders(customer_id, last_n=20)
        if len(orders) == 0:
            return 0.0
        returns = len([o for o in orders if o['status'] == 'returned'])
        return returns / len(orders)

# microservice-migration-agent.py
from typing import Dict, List
import os

class MicroserviceMigrationAgent:
    def __init__(self, monolith_path: str):
        self.monolith_path = monolith_path
        
    def extract_service(self, service_name: str, extraction_plan: Dict) -> List[str]:
        """
        Generate microservice from monolith using strangler fig pattern
        """
        files_created = []
        
        # Generate service boilerplate
        service_files = self._generate_service_code(service_name, extraction_plan)
        files_created.extend(service_files)
        
        # Generate routing configuration
        routing_config = self._generate_routing_config(service_name)
        files_created.append(routing_config)
        
        # Generate deployment manifests
        k8s_files = self._generate_k8s_manifests(service_name)
        files_created.extend(k8s_files)
        
        # Generate migration steps
        migration_plan = self._generate_migration_steps(service_name, extraction_plan)
        
        return files_created
    
    def _generate_routing_config(self, service_name: str) -> str:
        """Generate nginx routing for gradual traffic migration"""
        nginx_config = f"""
# Strangler fig routing for {service_name}
upstream legacy_backend {{
    server legacy-monolith:8080;
}}

upstream {service_name}_backend {{
    server {service_name}-service:8080;
}}

server {{
    listen 80;
    
    location ~* ^/api/{service_name}/(.*) {{
        # Feature flag based routing
        set $backend legacy_backend;
        
        # Route percentage of traffic to new service
        if ($arg_migrate = "true") {{
            set $backend {service_name}_backend;
        }}
        
        proxy_pass http://$backend/api/$1$is_args$args;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }}
    
    location / {{
        proxy_pass http://legacy_backend;
    }}
}}
"""
        nginx_file = f"infrastructure/nginx/{service_name}-routing.conf"
        os.makedirs(os.path.dirname(nginx_file), exist_ok=True)
        with open(nginx_file, 'w') as f:
            f.write(nginx_config)
        return nginx_file