The Vision

Every business decision is conditional logic. Every process is a loop. Every exception needs handling.

Business is software running on human runtime.

Claude Run replaces human runtime with programmable intelligence at runtime. This is not automation. This is intelligence that understands, acts, and evolves.

Business intent executes directly. No translation required.

The Problem

Businesses Drown in Operations

The average small business owner works 70 hours per week. 40 hours running operations. 30 hours trying to grow.

Every customer email needs reading. Every order needs processing. Every exception needs handling. The owner is the integration layer, the decision engine, the exception handler.

Growth means more operations. More operations means less time for growth. The cycle traps businesses at their current scale.

Why Previous Attempts Failed

AI agents and automation platforms promised to eliminate coding. They just moved it. Business still had to translate intent into machine instructions—just with different syntax.

They automated tasks, not understanding. Business still had to translate.

Part I: Claude Code - The Foundation

Claude Code isn't just a coding agent. It understands what you want, not just what you type. It does what you need, not just what you want.

Four fundamental capabilities enable this:

Understanding.
Grasps business intent, not just syntax. "Fix the inventory mismatch" means reconcile systems, not debug code. "Handle the edge case" means protect business operations, not catch exceptions. Powered by frontier reasoning.

Action.
Completes business tasks, not just generates code. When you say "process the refund," it validates the request, checks policies, executes the refund, notifies the customer, and updates records. Software that does.

Context.
CLAUDE.md captures your business DNA. Policies, patterns, precedents—your expertise becomes Claude Code's operating system. Not memory yet, but persistent understanding.

Connection.
Through MCP, systems become accessible through business vocabulary. "Check inventory" connects to your warehouse. "Verify customer status" queries your CRM. No API documentation required.

These capabilities exist in your terminal. The SDK makes them programmable.

Part II: The SDK - Making Claude Code Embeddable

The Claude Code SDK transforms terminal capabilities into programmable runtime. Terminal commands become API calls. Error handling ensures resilience. Any application can embed Claude Code directly.

[Official SDK: docs.anthropic.com/claude-code/sdk]

Five mechanisms enable this transformation:

// Continue yesterday's order processing with full context
await sdk.query({
  prompt: 'Process remaining orders from yesterday',
  options: { continueSession: true }  // Picks up exactly where we left off
});

// Or resume a specific order session by ID
await sdk.query({
  prompt: 'Complete the bulk order',
  options: { resumeSessionId: 'order-session-123' }
});

// Claude Code becomes your domain expert
await sdk.query({
  prompt: 'Review customer claim #4821',
  options: {
    systemPrompt: `You operate our insurance business.
      Apply regulation 247.3 for water damage claims.
      Flag patterns matching our fraud indicators.
      Use our 3-tier approval matrix for settlements.
      15 years of company precedents guide your decisions.`,
    continueSession: true
  }
});

// Your business logic becomes Claude Code's operating system

// Start restricted - read only analysis
await sdk.query({
  prompt: 'Analyze customer patterns',
  options: {
    allowedTools: ['Read', 'Grep'],
    disallowedTools: ['Write', 'Edit']
  }
});

// Add MCP tools with specific permissions
await sdk.mcp.add('crm', {
  command: 'npx @modelcontext/salesforce-server'
});

// Progressive trust expansion
await sdk.query({
  prompt: 'Process orders',
  options: {
    allowedTools: ['mcp__crm__query', 'mcp__inventory__check'],
    disallowedTools: ['mcp__payments__charge'],  // Payment restricted
    permissionMode: 'acceptEdits'  // Require approval for edits
  }
});

// Monitor order validation in real-time
const stream = await sdk.query({
  prompt: 'Validate and process bulk order'
});

for await (const message of stream) {
  if (message.type === 'assistant') {
    console.log(`Reasoning: ${message.text}`);
  }
  if (message.type === 'user') {
    console.log(`Tool used: ${message.tool}`);
  }
  
  // Business logic monitoring on streamed events
  if (message.text?.includes('high-value')) {
    await notifyManager(message);
  }
}

// Track patterns in order processing
const result = await sdk.query({
  prompt: 'Process customer order',
  options: { continueSession: true }
});

// Automatic telemetry captured
console.log({
  cost: result.total_cost_usd,
  duration: result.duration_ms,
  turns: result.num_turns,
  sessionId: result.session_id
});

// When patterns emerge, generate new capabilities
if (orderPattern.frequency > 5 && orderPattern.successRate > 0.9) {
  await generateOrderCapability(orderPattern);
}

These mechanisms bridge the gap between terminal tool and embeddable runtime.

Claude Code provides the capabilities. The SDK makes them programmable. Now see how Claude Run orchestrates both into business runtime.

Part III: The Claude Run Architecture

Claude Code provides intelligence. The SDK makes it programmable. Claude Run orchestrates both to run your business.

Not through monolithic automation. Through three intelligent components that work together:

1. Intelligence Router

Not everything needs full intelligence. The router decides what does.

// Cost-aware routing: $0.00 → $0.001 → $0.10
if (cachedPattern) return cache.execute();         // $0.00
if (knownPattern) return pattern.execute();       // $0.001
if (needsIntelligence) {
  return await sdk.query({
    prompt: 'Analyze and route business event',
    options: { maxCost: 0.10 }                      // $0.10
  });
}
return escalateToHuman();                           // $0.00

2. Execution Engine

Earns autonomy through demonstrated success.

// Progressive trust: 0.3 → 0.9
trustLevel 0.3: ['Read', 'mcp__email__send']          // Communicate
trustLevel 0.5: ['mcp__calendar__*', 'mcp__crm__*']   // Schedule
trustLevel 0.7: ['Write', 'mcp__payments__*']         // Transact
trustLevel 0.9: ['*']                                   // Full autonomy

// Trust grows through success, falls through failure
if (result.success && consecutiveSuccesses > 10) trust += 0.1;
if (result.failure) trust -= 0.2;

3. Learning System

Software that writes itself.

// Pattern threshold: 10+ occurrences, 95% success
if (pattern.frequency > 10 && pattern.successRate > 0.95) {
  const capability = await sdk.query({
    prompt: 'Generate MCP server for this pattern',
    options: { 
      systemPrompt: 'Create production-ready capability',
      allowedTools: ['Write']
    }
  });
  await requestHumanApproval(capability);
}

Evolution: HVAC Emergency Dispatch

Three components. Cost-aware routing. Progressive trust. Self-evolution.

But how does this actually work in practice?

Evolution: From Theory to Reality

The three components work together. Here's how one real pattern evolves from first encounter to autonomous capability:

// First encounter with emergency
await sdk.query({
  prompt: 'Handle emergency: AC failure with infant',
  options: {
    systemPrompt: 'You run CoolAir HVAC',
    allowedTools: ['mcp__dispatch__*', 'mcp__sms__*']
  }
});

// Pattern recognized and cached
const emergencyPattern = {
  trigger: 'AC failure + vulnerable person',
  actions: [
    'classify_urgency',
    'find_nearest_tech',
    'dispatch_immediately',
    'notify_all_parties'
  ],
  success_rate: 1.0
};

// Self-generated capability
class EmergencyDispatch {
  async handle(event) {
    const urgency = this.assessUrgency(event);
    if (urgency === 'CRITICAL') {
      const tech = await this.findNearestTech();
      await this.dispatch(tech, event);
      await this.notifyCustomer(event, tech.eta);
      await this.escalateToOwner(event);
    }
  }
}

// System-generated enhancement
if (customer.profile.includes('elderly')) {
  tech.instructions.add('Check medication storage temp');
  followUp.schedule('24 hours');
}

Part IV: The Revolution

After seeing the architecture, the evolution, and the implementation—what actually changes for business?

Everything.

What Dies

What Emerges

The IT department doesn't get faster. It disappears.

Business logic doesn't get translated better. It stops being translated.

Part V: Implementation Roadmap

Progressive implementation. Trust earned at every stage.

// Minimal viable setup
const claudeRun = new ClaudeRun({
  business: 'YourBusiness',
  dailyLimit: 50,           // $50/day max
  trustLevel: 0.3,           // Start restricted
  channels: ['email']        // Single channel
});

The Bottom Line

Claude Run isn't software that businesses run.
It's software that runs businesses.

Not through rigid automation.
Through intelligent orchestration that understands, learns, and evolves.

Your business logic becomes directly executable.
Your patterns become permanent capabilities.
Your growth becomes unlimited.

The revolution isn't coming.
It's here.