ai-company-ops

name	ai-company-ops
description	Run your company with AI agents. Agent team architecture, autonomous workflows, client onboarding automation, inbox management, and heartbeat systems. Use when: user asks about "AI operations," "autonomous company," "agent workforce," "AI team structure," "automate my business," "AI employees," "agent orchestration," "run business with AI," or "AI-powered operations."
metadata	{"author":"Cybrflux","version":"1.0.0","tags":["ai-ops","automation","agents","workflows","business-operations","orchestration"]}

AI Company Ops — Run Your Business with AI Agents

This is how Cybrflux operates. We don't have employees for repetitive tasks. We have agents—AI systems that work 24/7, never forget, and scale infinitely.

This skill teaches you to build an AI-powered operating system for your company. Not just chatbots. Autonomous agents that handle real work: onboarding clients, managing inboxes, qualifying leads, generating reports, and maintaining institutional memory.

---

When to Use

• Starting a New Company — Build AI-native from day one
• Scaling Without Hiring — Handle 10x volume without headcount
• Replacing Repetitive Work — Automate tasks draining your time
• Client Onboarding — Instant, consistent, 24/7 welcome experience
• Inbox Management — AI triage, drafting, and response
• Lead Pipeline — Full automation from scrape to qualified opportunity
• Daily Operations — Briefings, reports, monitoring, alerts

Trigger phrases: "AI operations," "autonomous company," "agent workforce," "AI team structure," "automate my business," "AI employees," "agent orchestration," "run business with AI," "AI-powered operations," "build AI team"

---

The Agent Team Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                         ORCHESTRATOR (You / Human-in-the-Loop)          │
│                    Strategic decisions, exceptions, approvals             │
└─────────────────────────────────────────────────────────────────────────┘
                                    │
           ┌────────────────────────┼────────────────────────┐
           │                        │                        │
           ▼                        ▼                        ▼
┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
│  INGESTION      │      │  PROCESSING     │      │  EXECUTION      │
│  AGENTS         │      │  AGENTS         │      │  AGENTS         │
│                 │      │                 │      │                 │
│ • Email Scout   │      │ • Lead Scorer   │      │ • Outreach      │
│ • Web Monitor   │      │ • Data Enricher │      │ • Onboarder     │
│ • Form Handler  │      │ • Classifier    │      │ • Reporter      │
│ • Calendar Sync │      │ • Extractor     │      │ • Notifier      │
└────────┬────────┘      └────────┬────────┘      └────────┬────────┘
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  │
                    ┌─────────────┴─────────────┐
                    │      MEMORY LAYER         │
                    │   (Vector DB + State)     │
                    │                           │
                    │ • Conversation history    │
                    │ • Client context          │
                    │ • Knowledge base          │
                    │ • Agent state             │
                    └───────────────────────────┘

---

Model Selection Matrix

Not all AI tasks need the smartest (and most expensive) model. Match the model to the job:

Task Type	Complexity	Recommended Model	Cost/1K Tokens	Why
Quick Classification	Low	GPT-4o-mini	$0.00015	Fast, cheap, reliable
Data Extraction	Low-Med	Claude 3 Haiku	$0.00025	Good at structure
Email Drafting	Medium	GPT-4o	$0.005	Natural, professional tone
Complex Reasoning	High	Claude 3.5 Sonnet	$0.003	Best at multi-step logic
Code Generation	High	GPT-5.3-Codex	$0.015	SOTA coding ability
Creative Writing	High	Claude 3 Opus	$0.015	Best prose quality
Image Analysis	Variable	GPT-4o Vision	$0.005	Multimodal Swiss Army knife

Cost Optimization Strategy

# Multi-tier model routing
class ModelRouter:
    def __init__(self):
        self.tiers = {
            'fast': 'gpt-4o-mini',      # 90% of tasks
            'standard': 'gpt-4o',        # 8% of tasks
            'smart': 'claude-3.5-sonnet', # 2% of tasks
        }
    
    def route(self, task):
        # Classification determines tier
        if task.type in ['classification', 'tagging', 'simple_extraction']:
            return self.tiers['fast']
        elif task.type in ['drafting', 'summarization']:
            return self.tiers['standard']
        else:  # reasoning, complex analysis
            return self.tiers['smart']

# Result: 70% cost reduction vs using GPT-4o for everything

---

The Heartbeat System

Every AI company needs a heartbeat—a regular pulse that keeps operations running and surfaces what needs human attention.

Heartbeat Architecture

# config/heartbeat.yml
heartbeats:
  # Every 15 minutes - Real-time monitoring
  frequent:
    interval: 15min
    tasks:
      - check_critical_inboxes
      - monitor_website_uptime
      - alert_on_high_priority_events
  
  # Every hour - Operational tasks
  hourly:
    interval: 1h
    tasks:
      - process_new_leads
      - draft_pending_responses
      - update_metrics_dashboard
      - check_calendar_conflicts
  
  # Twice daily - Business intelligence
  bi_daily:
    interval: 12h
    tasks:
      - generate_lead_report
      - review_pipeline_health
      - flag_expiring_opportunities
      - summarize_conversations
  
  # Daily - Strategic overview
  daily:
    interval: 24h
    time: "08:00"
    tasks:
      - generate_morning_briefing
      - calculate_daily_metrics
      - review_agent_performance
      - identify_blocked_items

Morning Briefing Template

// agents/briefing-agent.js
class MorningBriefingAgent {
  async generate(user) {
    const [leads, inbox, calendar, metrics] = await Promise.all([
      this.getLeadSummary(since: '24h'),
      this.getInboxStatus(),
      this.getCalendarToday(),
      this.getKeyMetrics()
    ]);
    
    return {
      headline: this.generateHeadline(metrics),
      sections: [
        {
          title: "🔥 Needs Attention",
          items: [
            ...inbox.urgent.map(e => `Email from ${e.from}: "${e.subject}"`),
            ...leads.hot.map(l => `Hot lead: ${l.company} (${l.score}/100)`),
            ...calendar.conflicts.map(c => `Calendar conflict: ${c.title}`)
          ]
        },
        {
          title: "📈 Last 24 Hours",
          items: [
            `${leads.new} new leads (${leads.qualified} qualified)`,
            `${metrics.revenue} revenue processed`,
            `${metrics.conversionRate}% trial-to-paid conversion`
          ]
        },
        {
          title: "📅 Today",
          items: calendar.events.map(e => 
            `${e.time}: ${e.title} ${e.needsPrep ? '(prep needed)' : ''}`
          )
        },
        {
          title: "🤖 Agent Activity",
          items: [
            `${metrics.emailsDrafted} emails drafted`,
            `${metrics.leadsEnriched} leads enriched`,
            `${metrics.responsesSent} responses sent`
          ]
        }
      ],
      actions: this.suggestActions(leads, inbox)
    };
  }
  
  generateHeadline(metrics) {
    if (metrics.revenue > metrics.revenueYesterday * 1.5) {
      return "🚀 Strong day—revenue up 50% vs yesterday";
    } else if (metrics.blockedItems > 3) {
      return "⚠️  Several items need your decision";
    }
    return "📊 Steady day ahead";
  }
}

---

Client Onboarding Automation

The Onboarding Flow

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Contract  │───▶│  Welcome    │───▶│  Discovery  │───▶│   Setup     │
│   Signed    │    │   Email     │    │   Call/Form │    │   Begins    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
      │                  │                  │                  │
      ▼                  ▼                  ▼                  ▼
Webhook fires      Personalized      AI conducts       Automated
Trigger: contract  video sent        intake:           provisioning
status = signed    Calendly link     - Goals           - Accounts
                   to book kickoff   - Requirements    - Access
                                     - Timeline        - Templates

Onboarding Agent Implementation

// agents/onboarding-agent.js
class ClientOnboardingAgent {
  constructor(config) {
    this.crm = config.crm; // Integration
    this.email = config.emailService;
    this.video = config.loomApi; // or similar
    this.calendar = config.calendar;
  }
  
  async startOnboarding(client) {
    // 1. Create client workspace/accounts
    await this.provisionClientResources(client);
    
    // 2. Generate personalized welcome video
    const welcomeVideo = await this.generateWelcomeVideo(client);
    
    // 3. Send onboarding sequence
    await this.sendOnboardingEmail(client, welcomeVideo);
    
    // 4. Schedule discovery call if needed
    if (client.plan === 'enterprise') {
      await this.scheduleKickoffCall(client);
    }
    
    // 5. Create onboarding checklist
    await this.createChecklist(client);
    
    // 6. Notify internal team
    await this.notifyTeam(client);
  }
  
  async generateWelcomeVideo(client) {
    // Use personalized video generation or Loom recording template
    const script = `
      Hi ${client.primaryContact.firstName},
      
      I'm excited to welcome you to ${this.companyName}! 
      
      You signed up for the ${client.plan} plan, which means you'll get
      ${this.getPlanFeatures(client.plan).join(', ')}.
      
      I've already started setting up your account. Here's what happens next...
    `;
    
    return await this.video.generate({
      script,
      template: 'professional-welcome',
      personalization: {
        name: client.primaryContact.firstName,
        company: client.companyName
      }
    });
  }
  
  async sendOnboardingEmail(client, video) {
    const sequence = [
      {
        delay: 0, // Immediate
        subject: `Welcome to ${this.companyName}, ${client.primaryContact.firstName}!`,
        body: `
          <h1>We're excited to work with you!</h1>
          <p>Hi ${client.primaryContact.firstName},</p>
          <p>I've recorded a quick personal welcome for you:</p>
          <a href="${video.url}" style="...">▶ Watch your welcome video</a>
          <p>Next steps:</p>
          <ol>
            <li>Watch the welcome video (3 min)</li>
            <li>Complete your intake survey</li>
            <li>Book your kickoff call</li>
          </ol>
        `
      },
      {
        delay: 24, // hours
        condition: 'intake_not_completed',
        subject: 'Quick reminder: Your intake survey',
        body: `...`
      },
      {
        delay: 72,
        condition: 'kickoff_not_booked',
        subject: 'Let's get your kickoff scheduled',
        body: `...`
      }
    ];
    
    for (const email of sequence) {
      await this.scheduleEmail(client.email, email);
    }
  }
}

---

Inbox Management System

The Triage Agent

// agents/inbox-triage-agent.js
class InboxTriageAgent {
  async processEmail(email) {
    // 1. Classify intent
    const classification = await this.classify(email);
    
    // 2. Extract key information
    const entities = await this.extract(email);
    
    // 3. Determine action
    const action = await this.decideAction(classification, entities);
    
    // 4. Execute
    switch (action.type) {
      case 'auto_respond':
        return await this.sendResponse(email, action.draft);
        
      case 'draft_for_review':
        return await this.createDraft(email, action.draft);
        
      case 'delegate':
        return await this.assignToTeamMember(email, action.assignee);
        
      case 'ignore':
        return await this.archive(email);
        
      case 'flag_urgent':
        return await this.notifyUrgent(email);
    }
  }
  
  async classify(email) {
    const prompt = `
      Classify this email into exactly one category:
      - SALES_INQUIRY: Someone asking about services/pricing
      - SUPPORT_REQUEST: Existing customer needs help
      - PARTNERSHIP: Business development opportunity
      - SPAM: Unsolicited, irrelevant
      - NEWSLETTER: Subscription content
      - BILLING: Invoice, payment, subscription issue
      - OTHER: Doesn't fit above
      
      Also extract:
      - Urgency: URGENT (time-sensitive), NORMAL, LOW
      - Sentiment: POSITIVE, NEUTRAL, NEGATIVE, FRUSTRATED
      
      Email:
      From: ${email.from}
      Subject: ${email.subject}
      Body: ${email.body.substring(0, 2000)}
    `;
    
    return await this.llm.classify(prompt);
  }
  
  async decideAction(classification, entities) {
    // Rules engine + AI reasoning
    const rules = [
      {
        if: c => c.category === 'SPAM' || c.category === 'NEWSLETTER',
        then: { type: 'ignore' }
      },
      {
        if: c => c.urgency === 'URGENT' && c.sentiment === 'FRUSTRATED',
        then: { type: 'flag_urgent' }
      },
      {
        if: c => c.category === 'SALES_INQUIRY' && this.confidence > 0.9,
        then: { type: 'auto_respond', template: 'sales_inquiry' }
      },
      {
        if: c => c.category === 'SUPPORT_REQUEST',
        then: { type: 'draft_for_review', template: 'support_response' }
      }
    ];
    
    // Find matching rule or default to draft_for_review
    const rule = rules.find(r => r.if(classification));
    return rule ? rule.then : { type: 'draft_for_review' };
  }
}

Response Drafting Templates

const RESPONSE_TEMPLATES = {
  sales_inquiry: {
    context: `
      You are a helpful sales assistant for {{companyName}}.
      The prospect is asking about {{service}}.
      
      Guidelines:
      - Be enthusiastic but professional
      - Ask 1-2 qualifying questions
      - Offer a call to discuss their needs
      - Include pricing only if specifically asked
    `,
    structure: `
      1. Thank them for reaching out
      2. Show you understand their need
      3. Ask qualifying question(s)
      4. Propose next step (call/demo)
      5. Professional sign-off
    `
  },
  
  support_response: {
    context: `
      You are a technical support specialist for {{companyName}}.
      The customer is experiencing: {{issue}}
      
      Guidelines:
      - Acknowledge frustration if they seem upset
      - Provide clear step-by-step solution
      - Offer escalation path if issue persists
    `,
    structure: `
      1. Acknowledge the issue
      2. Provide solution steps
      3. Set expectation for resolution
      4. Offer further help
    `
  }
};

---

Lead Pipeline Automation

Full Pipeline Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                         LEAD PIPELINE                                   │
└─────────────────────────────────────────────────────────────────────────┘

SOURCES                        ENRICHMENT              QUALIFICATION
─────────                      ───────────              ─────────────
┌─────────┐                   ┌─────────────┐          ┌─────────────┐
│ Website │                   │  Apollo.io  │          │ Lead Scorer │
│  Forms  │──────────────────▶│  Clearbit   │─────────▶│  (AI Model) │
└─────────┘                   │  Hunter.io  │          └──────┬──────┘
                              └─────────────┘                 │
┌─────────┐                                                   │
│ LinkedIn│                                                   ▼
│ Scraping│                   ┌─────────────┐          ┌─────────────┐
└─────────┘──────────────────▶│  AI Email   │          │ Qualified?  │
                              │  Verifier   │          │  Y / N      │
┌─────────┐                   └─────────────┘          └──────┬──────┘
│ Ad      │                                                   │
│ Leads   │                                                   │
└─────────┘                                                   │
                                                              │
                    ┌─────────────────────────────────────────┘
                    │
                    ▼
         ┌─────────────────────┐
         │   ROUTING DECISION  │
         └──────────┬──────────┘
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
  ┌─────────┐ ┌─────────┐ ┌─────────┐
  │ HOT     │ │ WARM    │ │ COLD    │
  │ (Score  │ │ (Score  │ │ (Score  │
  │  80+)   │ │ 50-79)  │ │ <50)    │
  └────┬────┘ └────┬────┘ └────┬────┘
       │           │           │
       ▼           ▼           ▼
  ┌─────────┐ ┌─────────┐ ┌─────────┐
  │ Instant │ │ Nurture │ │ Long-   │
  │ Meeting │ │ Sequence│ │ term    │
  │ Booked  │ │ (Email) │ │ Nurture │
  └─────────┘ └─────────┘ └─────────┘

Lead Scoring Model

// models/lead-scorer.js
class LeadScorer {
  score(lead) {
    let score = 0;
    
    // Firmographic scoring
    if (lead.companySize) {
      score += this.companySizeScore(lead.companySize);
    }
    if (lead.industry) {
      score += this.industryScore(lead.industry);
    }
    if (lead.funding) {
      score += this.fundingScore(lead.funding);
    }
    
    // Behavioral scoring
    if (lead.source === 'demo_request') score += 25;
    if (lead.source === 'pricing_page') score += 20;
    if (lead.source === 'content_download') score += 10;
    if (lead.source === 'cold_outreach') score += 5;
    
    // Engagement scoring
    if (lead.emailOpens > 3) score += 10;
    if (lead.websiteVisits > 2) score += 15;
    if (lead.pricingPageViews > 0) score += 20;
    
    // Contact quality
    if (lead.hasDirectEmail) score += 10;
    if (lead.hasPhone) score += 5;
    if (lead.title?.match(/CEO|CTO|VP|Director/i)) score += 15;
    
    return Math.min(score, 100);
  }
  
  companySizeSize(size) {
    // Higher score for ideal customer size
    if (size >= 50 && size <= 500) return 25;  // Sweet spot
    if (size > 500 && size <= 2000) return 20;
    if (size > 2000) return 15;
    if (size >= 10 && size < 50) return 15;
    return 10;
  }
}

---

Memory & Continuity

The Memory Stack

// memory/conversation-memory.js
class ConversationMemory {
  constructor(vectorDb, redis) {
    this.vectorDb = vectorDb;  // Pinecone, Weaviate, etc.
    this.redis = redis;        // Short-term state
  }
  
  async storeInteraction(sessionId, interaction) {
    // 1. Store in vector DB for semantic search
    await this.vectorDb.upsert({
      id: `${sessionId}-${interaction.timestamp}`,
      vector: await this.embed(interaction.content),
      metadata: {
        sessionId,
        timestamp: interaction.timestamp,
        type: interaction.type,
        summary: interaction.summary
      }
    });
    
    // 2. Update session state in Redis
    await this.redis.hSet(`session:${sessionId}`, {
      lastInteraction: Date.now(),
      context: JSON.stringify(interaction.extractedContext),
      summary: await this.summarizeSession(sessionId)
    });
  }
  
  async getRelevantContext(sessionId, query, limit = 5) {
    // Semantic search across conversation history
    const queryVector = await this.embed(query);
    
    const results = await this.vectorDb.query({
      vector: queryVector,
      filter: { sessionId },
      topK: limit
    });
    
    return results.matches.map(m => m.metadata);
  }
  
  async summarizeSession(sessionId) {
    const history = await this.getSessionHistory(sessionId);
    
    const prompt = `
      Summarize this conversation in 3-4 bullet points.
      Focus on: what the user wants, key information shared, and next steps.
      
      Conversation:
      ${history.map(h => `${h.role}: ${h.content}`).join('\n')}
    `;
    
    return await this.llm.complete(prompt);
  }
}

Cross-Session Memory

// memory/client-memory.js
class ClientMemory {
  async getClientContext(clientId) {
    const [profile, history, preferences, notes] = await Promise.all([
      this.getProfile(clientId),
      this.getInteractionHistory(clientId, limit: 20),
      this.getPreferences(clientId),
      this.getInternalNotes(clientId)
    ]);
    
    return {
      profile,
      recentInteractions: history,
      preferences,
      internalNotes: notes,
      relationshipSummary: await this.generateRelationshipSummary(history)
    };
  }
  
  async generateRelationshipSummary(interactions) {
    const prompt = `
      Based on these interactions, summarize the relationship:
      - How long have we known them?
      - What's their current status (prospect, customer, churned)?
      - Any ongoing issues or opportunities?
      - Communication preferences?
      - Key decision makers involved?
      
      Interactions: ${JSON.stringify(interactions)}
    `;
    
    return await this.llm.complete(prompt);
  }
}

---

Agent Orchestration

Workflow Definition Language

# workflows/client-intake.yml
name: Client Intake Workflow
version: 1.0.0
triggers:
  - type: webhook
    event: contract.signed
    
steps:
  - id: provision_account
    agent: provisioning_agent
    action: createClientWorkspace
    input:
      clientId: "{{trigger.clientId}}"
      plan: "{{trigger.plan}}"
      
  - id: send_welcome
    agent: communication_agent
    action: sendEmail
    dependsOn: [provision_account]
    input:
      template: welcome_sequence_1
      personalization:
        firstName: "{{trigger.contact.firstName}}"
        loginUrl: "{{steps.provision_account.loginUrl}}"
        
  - id: schedule_kickoff
    agent: calendar_agent
    action: findAndBookSlot
    condition: "{{trigger.plan}} == 'enterprise'"
    input:
      attendees: ["{{trigger.contact.email}}", "[e-mail]"]
      duration: 30
      title: "Kickoff: {{trigger.clientName}}"
      
  - id: notify_slack
    agent: notification_agent
    action: sendMessage
    input:
      channel: "#new-clients"
      message: |
        🎉 New client signed: {{trigger.clientName}}
        Plan: {{trigger.plan}}
        Kickoff: {{steps.schedule_kickoff.scheduledTime || "Not scheduled"}}
        
  - id: wait_for_intake
    type: delay
    duration: 24h
    
  - id: followup_if_needed
    agent: communication_agent
    action: sendEmail
    condition: "{{steps.wait_for_intake.intakeCompleted}} == false"
    input:
      template: intake_reminder

---

Daily Operations Checklist

Morning (Automated)

• Briefing generated — Sent to your preferred channel (email/Slack)
• Inbox triaged — Urgent items flagged, drafts ready for review
• Lead pipeline updated — New leads scored, hot leads surfaced
• Calendar checked — Conflicts flagged, prep materials ready
• Metrics calculated — Yesterday's performance summarized

Throughout Day (Triggered)

• New lead notification — Hot leads pinged immediately
• Email draft ready — Important emails drafted for your approval
• Meeting prep delivered — 15 min before each meeting
• Follow-up reminders — Promised actions surfaced

Evening (Automated)

• Day summary — What happened, what needs follow-up
• Tomorrow preview — Calendar, prep needed
• Metrics snapshot — Day's performance vs targets

---

Cross-References

• ai-voice-agent — Add voice agents to your AI operations
• lead-machine — End-to-end lead generation system
• email-sequence — Automated nurture campaigns
• analytics-tracking — Measure your AI operations

---

Getting Started Checklist

Week 1: Foundation

• Choose your model stack (fast/standard/smart)
• Set up vector database (Pinecone/Weaviate)
• Deploy heartbeat system with basic morning briefing
• Connect one data source (email or leads)

Week 2: First Agents

• Deploy inbox triage agent
• Create first automated workflow
• Set up client memory system
• Build basic lead scoring

Week 3: Integration

• Connect all data sources
• Create onboarding automation
• Build daily briefing customization
• Set up monitoring dashboards

Week 4: Optimization

• Review agent performance
• Tune classification accuracy
• Expand automation coverage
• Document exceptions for human review

Result: 80% of repetitive work automated. You focus on strategy, exceptions, and growth.