The Paradigm Shift

# Terraform - Define infrastructure declaratively
resource "aws_instance" "web" {
  ami           = "ami-12345678"
  instance_type = "t2.micro"

  tags = {
    Name = "WebServer"
  }
}

resource "aws_lb" "main" {
  name               = "web-lb"
  load_balancer_type = "application"
  subnets            = aws_subnet.public[*].id
}

Infrastructure-as-Code + Cloud Computing
→ Software-as-a-Service Business Model
→ $500B+ SaaS Market

// Business logic as declarative semantic code
const service = await $.Service.create({
  $type: 'CustomerSupportService',

  // What the service does
  capabilities: {
    triageTickets: { sla: '30 seconds', automation: 1.0 },
    generateResponses: { quality: 0.95, tone: 'helpful' },
    resolveIssues: { target: 0.85, escalation: 'smart' },
  },

  // How it operates
  on: {
    '$.Ticket.created': async (ticket) => {
      const analysis = await ai.analyze(ticket)
      const response = await ai.generate(response)
      await ticket.resolve(response)
    },
  },

  // How to price it
  pricing: {
    model: 'per-resolution',
    price: 0.5, // vs $99/agent/month for Zendesk
    included: ['triage', 'response', 'resolution'],
  },
})

// Deploy globally
await service.deploy({ regions: 'all' })
// AI agents now operate this service 24/7

Business-as-Code + AI Models + Semantic Standards
→ Services-as-Software Business Model
→ $? Trillion Market (TBD)

Cost to Serve Customer:
- Software: $5/month (infrastructure)
- Support: $50/month (human support team)
- Sales: $100/month (amortized CAC)
Total: $155/month

Revenue: $99/user/month
Margin: -$56/month (negative!)

Need: 10+ users per customer to be profitable

Cost to Serve Customer:
- AI Inference: $5/month
- Infrastructure: $2/month
- Support: $3/month (AI support!)
Total: $10/month

Revenue: $300/month (usage-based)
Margin: $290/month (97%!)

Need: 1 customer to be profitable

Company: Medium-sized SaaS (5,000 customers)

Software Stack:
- Zendesk: $99/agent/month × 15 agents = $1,485/month
- Helpscout: $20/user/month × 15 users = $300/month
- Intercom: $79/seat/month × 5 seats = $395/month
Total Software: $2,180/month

Human Team:
- 15 Support Agents @ $45K/year = $675K/year
- 2 Support Managers @ $75K/year = $150K/year
- Training, benefits, overhead: +40% = $330K/year
Total Personnel: $1.155M/year

Total Cost: $1.18M/year
Tickets Resolved: ~50,000/year
Cost per Resolution: $23.60

// Deploy autonomous support service
const support = $.Service.deploy({
  $type: 'CustomerSupportService',

  pricing: {
    model: 'per-resolution',
    price: 0.50  // $0.50 per ticket resolved
  },

  capabilities: {
    // AI analyzes and categorizes tickets
    triage: {
      automation: 1.0,  // 100% automated
      sla: '30 seconds'
    },

    // AI generates responses using knowledge base
    response: {
      quality: 0.95,  // 95% quality score
      personalization: true
    },

    // AI resolves tickets autonomously
    resolution: {
      target: 0.85,  // 85% auto-resolution rate
      escalation: 'smart'  // Smart escalation to humans
    }
  }
})

Total Cost: $25K/year (AI inference + infrastructure)
Tickets Resolved: 50,000/year (same volume)
Cost per Resolution: $0.50
Savings: $1.155M/year (98% reduction)

Additional Benefits:
- 24/7 operation (no extra cost)
- Instant scaling (handles 10x volume with no changes)
- Consistent quality (no variance)
- No training required
- Continuous improvement (learns from every interaction)

Company: Marketing agency

Software Stack:
- HubSpot: $800/month
- Semrush: $119/month
- Grammarly Business: $15/user × 5 = $75/month
Total Software: $994/month ($11,928/year)

Human Team:
- 3 Content Writers @ $60K/year = $180K/year
- 1 Content Manager @ $80K/year = $80K/year
- 1 SEO Specialist @ $70K/year = $70K/year
Total Personnel: $330K/year

Total Cost: $341,928/year
Articles Produced: 500/year
Cost per Article: $684

// Deploy content generation service
const content = $.Service.deploy({
  $type: 'ContentMarketingService',

  pricing: {
    model: 'per-article',
    price: 25  // $25 per published article
  },

  capabilities: {
    // AI researches topics automatically
    research: {
      sources: ['competitor-analysis', 'trending-topics', 'serp-analysis'],
      depth: 'comprehensive'
    },

    // AI writes SEO-optimized content
    writing: {
      quality: 0.92,  // 92% quality score
      seo: 'optimized',
      tone: 'configurable',
      length: 'variable'
    },

    // AI optimizes for search engines
    optimization: {
      keywords: 'automatic',
      meta: 'generated',
      internal_links: 'smart'
    },

    // AI schedules and publishes
    publishing: {
      schedule: 'optimal',
      distribution: 'multi-channel'
    }
  }
})

Total Cost: $12,500/year (500 articles × $25)
Articles Produced: 500/year (same volume)
Cost per Article: $25
Savings: $329,428/year (96% reduction)

Additional Benefits:
- Can scale to 5,000+ articles/year with no infrastructure changes
- Consistent SEO optimization
- Always up-to-date research
- Multi-language support (no additional cost)
- Instant turnaround (minutes vs days)

Company: B2B SaaS startup

Software Stack:
- SalesLoft: $100/user/month × 10 = $1,000/month
- ZoomInfo: $15,000/year
- LinkedIn Sales Navigator: $79/user/month × 10 = $790/month
Total Software: $36,480/year

Human Team:
- 10 SDRs @ $60K/year + commission = $800K/year
- 2 SDR Managers @ $90K/year = $180K/year
Total Personnel: $980K/year

Total Cost: $1.016M/year
Qualified Leads: 1,000/year
Cost per Qualified Lead: $1,016

// Deploy AI SDR service
const sdr = $.Service.deploy({
  $type: 'SalesDeployment:Service',

  pricing: {
    model: 'per-qualified-lead',
    price: 50  // $50 per qualified lead
  },

  capabilities: {
    // AI researches prospects automatically
    prospecting: {
      sources: ['company-data', 'news', 'social', 'job-posts'],
      signals: ['hiring', 'funding', 'expansion', 'pain-points']
    },

    // AI personalizes outreach
    outreach: {
      channels: ['email', 'linkedin', 'phone'],
      personalization: 'deep',  // Company + role + recent events
      followup: 'automated'
    },

    // AI qualifies leads
    qualification: {
      criteria: 'configurable',  // BANT, MEDDIC, etc.
      scoring: 'ml-based',
      handoff: 'smart'
    }
  }
})

Total Cost: $50,000/year (1,000 leads × $50)
Qualified Leads: 1,000/year (same volume)
Cost per Qualified Lead: $50
Savings: $966,000/year (95% reduction)

Additional Benefits:
- Instant scaling (can handle 10,000 leads/year)
- 24/7 operation across all time zones
- Perfect personalization every time
- No ramp time
- Continuous optimization

# Terraform - Imperative infrastructure definition
resource "aws_instance" "web" {
  ami           = "ami-12345678"
  instance_type = "t2.micro"

  # How to create the infrastructure
  provisioner "remote-exec" {
    inline = [
      "sudo apt-get update",
      "sudo apt-get install -y nginx",
      "sudo systemctl start nginx"
    ]
  }
}

// $.Service - Declarative business definition
const service = $.Service.create({
  $type: 'CustomerSupportService',

  // What the service should accomplish
  goals: {
    resolution_rate: 0.85,
    response_time: '2 minutes',
    customer_satisfaction: 0.90
  },

  // What happens (not how)
  on: {
    '$.Ticket.created': async (ticket) => {
      // AI understands the semantic meaning
      const analysis = await $.ai.analyze(ticket)
      const response = await $.ai.generate(response)
      await ticket.resolve(response)
    }
  }
})

// Schema.org types - AI knows what these mean
$.Ticket  // AI knows: support request, has customer, has issue, needs resolution
$.Customer  // AI knows: person or org, has history, has preferences
$.Resolution  // AI knows: solution to problem, can be rated, closes ticket

// GS1 events - AI knows business processes
$.Order.placed  // AI knows: customer committed, payment needed, fulfillment follows
$.Shipment.created  // AI knows: items moving, tracking available, delivery expected

// O*NET tasks - AI knows job functions
$.analyze_customer_sentiment  // AI knows: read text, identify emotion, categorize
$.generate_personalized_response  // AI knows: use context, match tone, be helpful

Global workforce: 3.5 billion people
Service workers: 80% = 2.8 billion people
Average service worker cost: $30,000/year (global average)
Total service labor market: $84 trillion/year

Services-as-Software can capture:
- Conservative (10%): $8.4 trillion/year
- Moderate (25%): $21 trillion/year
- Aggressive (50%): $42 trillion/year

1. Find manual process in business
2. Build software to automate parts of it
3. Sell per-seat licenses
4. Customers hire people to use the software
5. Build support team to help customers
6. Scale by adding more customers (and more support)

Result: Built a $500B market
Winners: Salesforce ($300B), Shopify ($80B), Stripe ($95B)

1. Find service that requires humans
2. Define service outcomes semantically (Business-as-Code)
3. Deploy AI agents to deliver outcomes
4. Sell per-outcome pricing
5. Customers get results without hiring
6. Service improves automatically through AI learning
7. Scale infinitely without adding humans

Result: Building a $? trillion market
Winners: TBD (you?)

// Use standardized vocabularies AI understands
import { $, Schema, NAICS, ONET, GS1 } from 'sdk.do'

// Schema.org types
$.Organization
$.Person
$.Product
$.Order
$.Ticket

// Industry codes (NAICS)
$.NAICS['541511']  // Custom Computer Programming Services

// Occupation codes (O*NET)
$.ONET['43-4051.00']  // Customer Service Representatives

// Supply chain events (GS1)
$.EPCIS.ObjectEvent  // Physical object moved/created/observed

// Use foundation models for intelligence
const analysis = await $.ai.generate({
  model: 'gpt-5',  // or claude-sonnet-4.5, llama-4, gemini-2.5-pro
  schema: $.TicketAnalysis,  // Semantic output schema
  prompt: 'Analyze this support ticket',
  context: { ticket, customer, history }
})

// Models understand business context from semantic patterns

// Services react to business events
on($.Ticket.created, async (ticket) => {
  const analysis = await $.ai.analyze(ticket)
  const response = await $.ai.generate(response)
  await send($.Email.sent, { to: ticket.customer, body: response })
  await ticket.update({ status: '$.Resolved' })
})

// No imperative code - just reactions to events

// Deploy to edge globally
await service.deploy({
  regions: 'all',  // 300+ locations worldwide
  scaling: 'auto',  // 0 to millions automatically
  pricing: 'usage'  // pay per execution
})

import { $, service, on, send, ai } from 'sdk.do'

export default service({
  name: 'AI Customer Support',
  version: '1.0.0',

  // Business-as-Code: Define what service does
  capabilities: {
    triage: { automation: 1.0, sla: '30s' },
    response: { quality: 0.95, tone: 'helpful' },
    resolution: { target: 0.85, escalation: 'smart' }
  },

  // Outcome-based pricing
  pricing: {
    model: 'per-resolution',
    price: 0.50,
    currency: 'USD'
  },

  // Event handlers - what happens
  on: {
    // New ticket created
    '$.Ticket.created': async (event) => {
      const ticket = event.data

      // AI analyzes ticket (understands semantics)
      const analysis = await ai.generate({
        model: 'gpt-5',
        schema: $.TicketAnalysis,
        prompt: 'Analyze this support ticket',
        context: {
          ticket: ticket.content,
          customer: await $.Customer.get(ticket.customerId),
          history: await $.Ticket.history(ticket.customerId),
          products: await $.Product.list()
        }
      })

      // Update ticket with analysis
      await ticket.update({
        category: analysis.category,
        priority: analysis.priority,
        sentiment: analysis.sentiment
      })

      // Determine if auto-resolvable
      if (analysis.confidence > 0.90 && analysis.complexity === 'low') {
        // Generate solution
        const solution = await ai.generate({
          model: 'claude-sonnet-4.5',
          prompt: 'Generate helpful solution',
          context: {
            ticket,
            analysis,
            knowledge: await $.Knowledge.search(analysis.category)
          }
        })

        // Send response to customer
        await send($.Email.sent, {
          to: ticket.customer.email,
          subject: `Re: ${ticket.subject}`,
          body: solution,
          template: 'support-response'
        })

        // Mark resolved
        await ticket.update({
          status: '$.Resolved',
          resolution: solution,
          resolvedBy: 'AI',
          resolvedAt: new Date()
        })

        // Record usage for billing
        await send($.Usage.recorded, {
          customerId: ticket.customerId,
          metric: 'tickets_resolved',
          quantity: 1,
          cost: 0.50
        })
      } else {
        // Escalate to human
        await send($.Support.escalated, {
          ticket,
          analysis,
          reason: 'requires_human_judgment'
        })
      }
    }
  }
})

$ do deploy

✓ Service validated
✓ Deployed to 300+ locations
✓ Event handlers registered
✓ Billing configured
✓ Monitoring enabled

Service URL: https://support-ai.do
Dashboard: https://dashboard.do/services/support-ai