Partner Deployment

Deploy FAOS solutions efficiently for dozens or hundreds of clients. This guide covers deployment automation, multi-tenant management, and scaling strategies for successful partners.

Deployment Architecture

Multi-Tenant Structure

graph TB
    A[Partner Control Plane] --> B[Client Workspace 1]
    A --> C[Client Workspace 2]
    A --> D[Client Workspace N]

    B --> E[Agents]
    B --> F[Data]
    B --> G[Integrations]

    C --> H[Agents]
    C --> I[Data]
    C --> J[Integrations]

    D --> K[Agents]
    D --> L[Data]
    D --> M[Integrations]

    style A fill:#0066CC,color:#fff
    style B fill:#28A745,color:#fff
    style C fill:#28A745,color:#fff
    style D fill:#28A745,color:#fff

Key principles:

• Isolation: Each client workspace is fully isolated
• Shared templates: Deploy from centralized agent/workflow templates
• Independent scaling: Each workspace scales independently
• Centralized management: Control all deployments from partner dashboard

Automated Client Provisioning

Quick Provision Script

Automate the entire client onboarding process.

import { FAOS } from '@faos/sdk';

async function provisionNewClient(clientData) {
  const faos = new FAOS({
    apiKey: process.env.FAOS_PARTNER_API_KEY,
    environment: 'production'
  });

  console.log(`Provisioning client: ${clientData.name}...`);

  // Step 1: Create workspace
  const workspace = await faos.partners.workspaces.create({
    name: clientData.name,
    industry: clientData.industry,
    plan: clientData.plan,
    contact: clientData.contact,
    billing: {
      method: 'pass_through',
      currency: 'USD'
    }
  });

  console.log(`✓ Workspace created: ${workspace.id}`);

  // Step 2: Apply branding
  await faos.partners.branding.applyTheme({
    workspace_id: workspace.id,
    theme_id: clientData.theme_id || 'default-partner-theme'
  });

  console.log(`✓ Branding applied`);

  // Step 3: Deploy agents from templates
  const agentDeployments = clientData.agents.map(agentConfig =>
    faos.partners.templates.deployAgent({
      workspace_id: workspace.id,
      template_id: agentConfig.template_id,
      name: agentConfig.name,
      config: agentConfig.config
    })
  );

  const agents = await Promise.all(agentDeployments);
  console.log(`✓ Deployed ${agents.length} agents`);

  // Step 4: Set up integrations
  for (const integration of clientData.integrations) {
    await faos.integrations.create({
      workspace_id: workspace.id,
      type: integration.type,
      credentials: integration.credentials,
      config: integration.config
    });
  }

  console.log(`✓ Configured ${clientData.integrations.length} integrations`);

  // Step 5: Upload knowledge base
  if (clientData.knowledge_base) {
    for (const doc of clientData.knowledge_base) {
      await faos.knowledge.upload({
        workspace_id: workspace.id,
        file: doc.file,
        metadata: doc.metadata
      });
    }
    console.log(`✓ Knowledge base uploaded`);
  }

  // Step 6: Invite users
  for (const user of clientData.users) {
    await faos.partners.users.invite({
      workspace_id: workspace.id,
      email: user.email,
      role: user.role,
      send_welcome_email: true
    });
  }

  console.log(`✓ Invited ${clientData.users.length} users`);

  // Step 7: Deploy workflows
  if (clientData.workflows) {
    for (const workflow of clientData.workflows) {
      await faos.partners.templates.deployWorkflow({
        workspace_id: workspace.id,
        template_id: workflow.template_id,
        config: workflow.config
      });
    }
    console.log(`✓ Deployed ${clientData.workflows.length} workflows`);
  }

  console.log(`\n✓✓✓ Client ${clientData.name} fully provisioned!`);

  return {
    workspace_id: workspace.id,
    login_url: `https://agents.yourcompany.com/workspaces/${workspace.id}`,
    agents: agents,
    status: 'active'
  };
}

// Usage example
const newClient = await provisionNewClient({
  name: "Acme Corporation",
  industry: "manufacturing",
  plan: "professional",
  theme_id: "manufacturing-theme",

  contact: {
    name: "John Smith",
    email: "john@acme.com",
    phone: "+1-555-0199"
  },

  agents: [
    {
      template_id: "customer-service-agent",
      name: "Acme Support Agent",
      config: {
        autonomy_level: 2,
        business_hours: "9am-5pm EST"
      }
    },
    {
      template_id: "order-processing-agent",
      name: "Order Manager",
      config: {
        autonomy_level: 3,
        auto_approval_threshold: 1000
      }
    }
  ],

  integrations: [
    {
      type: "salesforce",
      credentials: { /* ... */ },
      config: { sync_enabled: true }
    }
  ],

  users: [
    { email: "john@acme.com", role: "admin" },
    { email: "support@acme.com", role: "user" }
  ],

  workflows: [
    { template_id: "customer-onboarding", config: {} }
  ]
});

console.log(`Client portal: ${newClient.login_url}`);

Provision from Configuration File

Store client configs as YAML for version control:

# clients/acme-corp.yaml
name: Acme Corporation
industry: manufacturing
plan: professional
theme_id: manufacturing-theme

contact:
  name: John Smith
  email: john@acme.com
  phone: +1-555-0199

agents:
  - template_id: customer-service-agent
    name: Acme Support Agent
    config:
      autonomy_level: 2
      business_hours: 9am-5pm EST

  - template_id: order-processing-agent
    name: Order Manager
    config:
      autonomy_level: 3
      auto_approval_threshold: 1000

integrations:
  - type: salesforce
    credentials_ref: acme-salesforce-creds
    config:
      sync_enabled: true

users:
  - email: john@acme.com
    role: admin
  - email: support@acme.com
    role: user

workflows:
  - template_id: customer-onboarding

Deploy from YAML:

# CLI tool for batch provisioning
faos-partner deploy --config clients/acme-corp.yaml

# Deploy multiple clients
faos-partner deploy --batch clients/*.yaml

Deployment Strategies

Strategy 1: Template-Based Deployment

Best for: Similar clients in the same industry

// Create industry-specific deployment template
const manufacturingTemplate = {
  agents: ['customer-service', 'order-processing', 'inventory'],
  workflows: ['order-fulfillment', 'customer-onboarding'],
  integrations: ['erp', 'crm', 'email'],
  autonomy_defaults: {
    customer_service: 2,
    order_processing: 3,
    inventory: 2
  }
};

// Deploy to multiple manufacturing clients
const manufacturingClients = [
  'acme-corp', 'widget-inc', 'parts-unlimited'
];

for (const clientId of manufacturingClients) {
  await deployFromTemplate(clientId, manufacturingTemplate);
}

Strategy 2: Phased Rollout

Best for: Complex deployments, minimizing risk

async function phasedDeployment(workspace_id) {
  // Phase 1: Core agents only (Week 1)
  await deployPhase1(workspace_id);
  await monitorAndValidate(workspace_id, { days: 7 });

  // Phase 2: Add workflows (Week 2)
  await deployPhase2(workspace_id);
  await monitorAndValidate(workspace_id, { days: 7 });

  // Phase 3: Full integration suite (Week 3)
  await deployPhase3(workspace_id);
  await monitorAndValidate(workspace_id, { days: 7 });

  // Phase 4: Advanced features (Week 4)
  await deployPhase4(workspace_id);

  console.log(`Full deployment complete for ${workspace_id}`);
}

Strategy 3: Blue-Green Deployment

Best for: Updating existing client deployments without downtime

async function blueGreenUpdate(workspace_id, newConfig) {
  // Create "green" environment with new config
  const greenEnv = await createStagingEnvironment(workspace_id, newConfig);

  // Test green environment
  const testResults = await runSmokeTests(greenEnv.id);

  if (testResults.passed) {
    // Switch traffic to green
    await switchEnvironment(workspace_id, greenEnv.id);

    // Keep blue for 24h rollback window
    await scheduleOldEnvironmentCleanup(workspace_id, { hours: 24 });
  } else {
    console.error('Green environment tests failed, staying on blue');
    await cleanupEnvironment(greenEnv.id);
  }
}

Bulk Operations

Bulk Agent Updates

Update agents across all clients:

// Update all customer service agents to new version
const workspaces = await faos.partners.workspaces.list();

for (const workspace of workspaces) {
  const agents = await faos.agents.list({
    workspace_id: workspace.id,
    filter: { template: 'customer-service-agent' }
  });

  for (const agent of agents) {
    await faos.agents.update(agent.id, {
      model: 'gpt-4-turbo', // Upgrade model
      system_prompt: updatedSystemPrompt,
      capabilities: [...agent.capabilities, 'new_capability']
    });
  }

  console.log(`Updated ${agents.length} agents in ${workspace.name}`);
}

Bulk Workflow Deployment

Deploy new workflow to all clients:

async function deployWorkflowToAll(template_id, config = {}) {
  const workspaces = await faos.partners.workspaces.list({
    status: 'active'
  });

  const results = await Promise.allSettled(
    workspaces.map(workspace =>
      faos.partners.templates.deployWorkflow({
        workspace_id: workspace.id,
        template_id,
        config: {
          ...config,
          // Client-specific overrides
          workspace_name: workspace.name
        }
      })
    )
  );

  const succeeded = results.filter(r => r.status === 'fulfilled').length;
  const failed = results.filter(r => r.status === 'rejected').length;

  console.log(`Deployed to ${succeeded}/${workspaces.length} clients`);
  if (failed > 0) {
    console.error(`Failed deployments: ${failed}`);
  }

  return results;
}

Migration Tools

Migrate Client to FAOS

Import existing client data:

async function migrateExistingClient(clientData, sourceSystem) {
  console.log(`Migrating ${clientData.name} from ${sourceSystem}...`);

  // Create workspace
  const workspace = await faos.partners.workspaces.create({
    name: clientData.name,
    industry: clientData.industry,
    plan: clientData.plan
  });

  // Import customer data
  await importCustomers(workspace.id, clientData.customers);

  // Import historical conversations
  await importConversations(workspace.id, clientData.conversations);

  // Import knowledge base
  await importKnowledgeBase(workspace.id, clientData.knowledge);

  // Deploy agents
  await deployAgents(workspace.id, clientData.agent_config);

  // Validate migration
  const validation = await validateMigration(workspace.id, clientData);

  if (validation.success) {
    console.log(`✓ Migration complete. ${validation.imported_records} records imported.`);
  } else {
    console.error(`Migration issues: ${validation.errors.join(', ')}`);
  }

  return workspace;
}

Export Client Data

For backups or migrations:

async function exportClientData(workspace_id) {
  const data = {
    workspace: await faos.partners.workspaces.get(workspace_id),
    agents: await faos.agents.list({ workspace_id }),
    workflows: await faos.workflows.list({ workspace_id }),
    integrations: await faos.integrations.list({ workspace_id }),
    knowledge: await faos.knowledge.list({ workspace_id }),
    conversations: await faos.conversations.export({ workspace_id }),
    analytics: await faos.analytics.export({ workspace_id })
  };

  // Save to file
  fs.writeFileSync(
    `exports/${workspace_id}-${Date.now()}.json`,
    JSON.stringify(data, null, 2)
  );

  console.log(`Exported data for workspace ${workspace_id}`);
  return data;
}

Monitoring & Management

Health Dashboard

Monitor all client deployments:

async function getDeploymentHealth() {
  const workspaces = await faos.partners.workspaces.list();

  const health = await Promise.all(
    workspaces.map(async workspace => {
      const agents = await faos.agents.list({ workspace_id: workspace.id });
      const activeAgents = agents.filter(a => a.status === 'active');

      const metrics = await faos.analytics.getMetrics({
        workspace_id: workspace.id,
        period: 'last_24h'
      });

      return {
        workspace_id: workspace.id,
        workspace_name: workspace.name,
        status: workspace.status,
        agents: {
          total: agents.length,
          active: activeAgents.length,
          inactive: agents.length - activeAgents.length
        },
        metrics: {
          interactions: metrics.total_interactions,
          success_rate: metrics.success_rate,
          avg_response_time: metrics.avg_response_time_ms,
          errors: metrics.error_count
        },
        health_score: calculateHealthScore(metrics)
      };
    })
  );

  return health;
}

function calculateHealthScore(metrics) {
  let score = 100;

  if (metrics.success_rate < 0.95) score -= 20;
  if (metrics.avg_response_time_ms > 2000) score -= 15;
  if (metrics.error_count > 10) score -= 15;

  return Math.max(0, score);
}

Alerts & Notifications

Set up proactive monitoring:

await faos.partners.monitoring.createAlert({
  name: "High Error Rate",
  condition: {
    metric: "error_rate",
    operator: ">",
    threshold: 0.05, // 5%
    period: "5m"
  },
  actions: [
    {
      type: "email",
      recipients: ["ops@yourcompany.com"]
    },
    {
      type: "slack",
      channel: "#alerts",
      severity: "high"
    }
  ],
  scope: "all_workspaces"
});

await faos.partners.monitoring.createAlert({
  name: "Agent Offline",
  condition: {
    metric: "agent_status",
    operator: "==",
    value: "offline",
    duration: "10m"
  },
  actions: [
    {
      type: "pagerduty",
      severity: "critical"
    }
  ]
});

Scaling Best Practices

Database Connection Pooling

For high-scale deployments:

const faos = new FAOS({
  apiKey: process.env.FAOS_PARTNER_API_KEY,
  connectionPool: {
    min: 10,
    max: 100,
    idleTimeoutMillis: 30000
  }
});

Rate Limiting

Respect API limits when managing many clients:

import pLimit from 'p-limit';

const limit = pLimit(10); // Max 10 concurrent operations

const workspaces = await faos.partners.workspaces.list();

const updates = workspaces.map(workspace =>
  limit(() => updateWorkspace(workspace.id, newConfig))
);

await Promise.all(updates);

Caching

Cache frequently accessed data:

import NodeCache from 'node-cache';

const cache = new NodeCache({ stdTTL: 300 }); // 5 min cache

async function getWorkspace(workspace_id) {
  const cacheKey = `workspace:${workspace_id}`;

  let workspace = cache.get(cacheKey);

  if (!workspace) {
    workspace = await faos.partners.workspaces.get(workspace_id);
    cache.set(cacheKey, workspace);
  }

  return workspace;
}

Disaster Recovery

Backup Strategy

// Daily backup of all client workspaces
async function dailyBackup() {
  const workspaces = await faos.partners.workspaces.list();

  for (const workspace of workspaces) {
    const backup = await exportClientData(workspace.id);

    // Upload to S3 or backup storage
    await uploadToBackupStorage(
      `backups/${workspace.id}/${Date.now()}.json`,
      backup
    );
  }

  console.log(`Backed up ${workspaces.length} workspaces`);
}

// Schedule daily at 2 AM
schedule.scheduleJob('0 2 * * *', dailyBackup);

Restore Process

async function restoreWorkspace(workspace_id, backup_timestamp) {
  const backup = await downloadFromBackupStorage(
    `backups/${workspace_id}/${backup_timestamp}.json`
  );

  // Restore data
  await faos.partners.workspaces.restore({
    workspace_id,
    data: backup,
    options: {
      overwrite: true,
      preserve_ids: true
    }
  });

  console.log(`Restored workspace ${workspace_id} from ${backup_timestamp}`);
}

Cost Optimization

Usage Monitoring

Track costs across clients:

async function getCostBreakdown(period = 'last_month') {
  const workspaces = await faos.partners.workspaces.list();

  const costs = await Promise.all(
    workspaces.map(async workspace => {
      const usage = await faos.analytics.getUsage({
        workspace_id: workspace.id,
        period
      });

      return {
        workspace_name: workspace.name,
        interactions: usage.total_interactions,
        cost: usage.total_cost,
        cost_per_interaction: usage.cost_per_interaction,
        revenue: workspace.billing.monthly_fee,
        margin: workspace.billing.monthly_fee - usage.total_cost
      };
    })
  );

  const totalCost = costs.reduce((sum, c) => sum + c.cost, 0);
  const totalRevenue = costs.reduce((sum, c) => sum + c.revenue, 0);
  const totalMargin = totalRevenue - totalCost;

  return {
    by_client: costs,
    totals: {
      cost: totalCost,
      revenue: totalRevenue,
      margin: totalMargin,
      margin_percentage: (totalMargin / totalRevenue) * 100
    }
  };
}

Optimize Agent Models

Use cheaper models where appropriate:

// Audit agents across all workspaces
async function optimizeAgentModels() {
  const workspaces = await faos.partners.workspaces.list();

  for (const workspace of workspaces) {
    const agents = await faos.agents.list({ workspace_id: workspace.id });

    for (const agent of agents) {
      const usage = await faos.analytics.getAgentUsage(agent.id);

      // If simple queries, downgrade to cheaper model
      if (usage.avg_complexity < 0.3 && agent.model === 'gpt-4') {
        await faos.agents.update(agent.id, {
          model: 'gpt-3.5-turbo'
        });
        console.log(`Optimized ${agent.name} in ${workspace.name}`);
      }
    }
  }
}

Next Steps

• Enterprise Setup - Self-hosted deployment
• Enterprise Security - Security hardening
• API Reference - Full API documentation

---

Scale with confidence. Automated deployment is the key to managing hundreds of clients efficiently.