5 OpenClaw Automations That Actually Make Money in 2026

# Install OpenClaw
curl -fsSL https://openclaw.ai/install.sh | bash

# Run onboarding wizard
openclaw onboard --install-daemon

# Connect Slack workspace
openclaw channels add slack --workspace your-workspace

// ~/.openclaw/skills/client-triage.js
export default {
  name: 'client-triage',
  description: 'Automatically categorize and prioritize client messages',
  
  async execute(context) {
    const { message, channel } = context;
    
    // Extract urgency signals
    const urgencyKeywords = ['urgent', 'asap', 'emergency', 'down', 'broken'];
    const isUrgent = urgencyKeywords.some(kw => 
      message.toLowerCase().includes(kw)
    );
    
    // Draft response based on context
    const response = await context.llm.generate({
      system: `You manage client communications. Draft professional responses.
               Check conversation history for context.`,
      prompt: `Client message: "${message}"
               Urgency: ${isUrgent ? 'HIGH' : 'NORMAL'}
               Draft a response and suggest next steps.`
    });
    
    // Route to appropriate channel
    if (isUrgent) {
      await context.notify('sms', '+1234567890', 
        `URGENT CLIENT: ${message.slice(0, 100)}...`
      );
    }
    
    return response;
  }
};

# ~/.openclaw/config/agents/client-manager.yaml
agent:
  name: "ClientManager"
  model: "claude-sonnet-4-20250514"
  
  triggers:
    - channel: "slack"
      pattern: "@ClientManager"
      auto_respond: true
      
  skills:
    - client-triage
    - calendar-check
    - draft-email
    
  guardrails:
    require_approval: true  # Human confirms before sending
    max_cost_per_day: 5.00  # Budget control

# Send test message to connected Slack channel
# Tag @ClientManager with a mock client request

# Check logs
openclaw logs --tail 20 --filter client-manager

// ~/.openclaw/skills/content-repurpose.js
export default {
  name: 'content-repurpose',
  
  async execute(context) {
    const { sourceUrl, outputFormats } = context.input;
    
    // Fetch and parse content
    const content = await context.browser.fetch(sourceUrl);
    const extracted = await context.llm.generate({
      system: 'Extract key points from this content',
      prompt: content.text
    });
    
    // Generate variants
    const outputs = {};
    
    if (outputFormats.includes('twitter')) {
      outputs.twitter = await this.generateTwitterThread(extracted, context);
    }
    
    if (outputFormats.includes('linkedin')) {
      outputs.linkedin = await this.generateLinkedInPost(extracted, context);
    }
    
    if (outputFormats.includes('newsletter')) {
      outputs.newsletter = await this.generateNewsletter(extracted, context);
    }
    
    // Auto-schedule with Buffer/Hootsuite
    for (const [platform, content] of Object.entries(outputs)) {
      await context.schedule.create({
        platform,
        content,
        publishAt: this.getOptimalTime(platform)
      });
    }
    
    return outputs;
  },
  
  async generateTwitterThread(keyPoints, context) {
    return await context.llm.generate({
      system: 'Create a Twitter thread (max 280 chars per tweet)',
      prompt: `Key points: ${keyPoints}
               Format: 5-7 tweet thread with hooks and CTAs`
    });
  },
  
  getOptimalTime(platform) {
    // Platform-specific best posting times
    const schedules = {
      twitter: '09:00',
      linkedin: '08:00', 
      newsletter: '06:00'
    };
    
    const today = new Date();
    const [hours, minutes] = schedules[platform].split(':');
    today.setHours(hours, minutes, 0);
    
    return today.toISOString();
  }
};

// ~/.openclaw/skills/lead-finder.js
export default {
  name: 'lead-finder',
  
  async execute(context) {
    const { searchQuery, industry } = context.input;
    
    // Monitor news and social media
    const mentions = await context.tools.web_search({
      query: `${searchQuery} ${industry} site:linkedin.com OR site:twitter.com`,
      since: 'last_7_days'
    });
    
    // Extract company names and decision makers
    const leads = [];
    
    for (const mention of mentions) {
      const analysis = await context.llm.generate({
        system: 'Extract company name, pain point, and decision maker if mentioned',
        prompt: mention.snippet
      });
      
      if (analysis.company) {
        // Enrich with contact data (using Apollo.io or similar)
        const enriched = await context.api.call('apollo', {
          endpoint: '/companies/search',
          params: { name: analysis.company }
        });
        
        leads.push({
          company: analysis.company,
          painPoint: analysis.painPoint,
          contact: enriched.contacts[0],
          source: mention.url
        });
      }
    }
    
    // Generate personalized outreach
    for (const lead of leads) {
      const email = await this.craftEmail(lead, context);
      
      // Save to CRM
      await context.api.call('hubspot', {
        endpoint: '/contacts',
        method: 'POST',
        data: {
          email: lead.contact.email,
          properties: {
            company: lead.company,
            pain_point: lead.painPoint,
            source_url: lead.source
          }
        }
      });
      
      // Schedule for manual review before sending
      await context.schedule.create({
        type: 'email',
        to: lead.contact.email,
        subject: email.subject,
        body: email.body,
        requireApproval: true
      });
    }
    
    return { leadsFound: leads.length };
  },
  
  async craftEmail(lead, context) {
    return await context.llm.generate({
      system: `Write personalized B2B outreach email. Reference specific pain point.
               Keep under 150 words. Include clear CTA.`,
      prompt: `Company: ${lead.company}
               Pain Point: ${lead.painPoint}
               Source: ${lead.source}`
    });
  }
};

// ~/.openclaw/skills/expense-tracker.js
export default {
  name: 'expense-tracker',
  
  async execute(context) {
    const { emailProvider } = context.config;
    
    // Monitor inbox for receipts
    const emails = await context.email.search({
      query: 'subject:(receipt OR invoice) has:attachment',
      since: 'yesterday'
    });
    
    const expenses = [];
    
    for (const email of emails) {
      // Extract text from PDF/image receipts
      const attachment = email.attachments[0];
      const text = await context.ocr.extract(attachment);
      
      // Parse expense details
      const parsed = await context.llm.generate({
        system: `Extract: vendor, amount, date, category from receipt text.
                 Return JSON only.`,
        prompt: text,
        responseFormat: 'json'
      });
      
      expenses.push({
        ...JSON.parse(parsed),
        sourceEmail: email.id,
        processedAt: new Date()
      });
    }
    
    // Update Google Sheets
    await context.api.call('googlesheets', {
      spreadsheetId: context.config.expenseSheetId,
      range: 'Expenses!A:E',
      method: 'append',
      data: expenses.map(e => [
        e.date, e.vendor, e.amount, e.category, e.sourceEmail
      ])
    });
    
    // Check budget alerts
    const monthlyTotal = expenses.reduce((sum, e) => sum + parseFloat(e.amount), 0);
    
    if (monthlyTotal > context.config.budgetLimit) {
      await context.notify('sms', context.config.ownerPhone,
        `⚠️ Budget alert: $${monthlyTotal} spent this month (limit: $${context.config.budgetLimit})`
      );
    }
    
    return { processed: expenses.length, total: monthlyTotal };
  }
};

// ~/.openclaw/skills/support-deflector.js
export default {
  name: 'support-deflector',
  
  async execute(context) {
    const { ticketingSystem } = context.config;
    
    // Monitor new tickets
    const tickets = await context.api.call('zendesk', {
      endpoint: '/tickets/recent',
      params: { status: 'new' }
    });
    
    for (const ticket of tickets) {
      // Search knowledge base
      const kbResults = await context.tools.vector_search({
        collection: 'support-docs',
        query: ticket.description,
        topK: 3
      });
      
      // Determine if auto-resolvable
      const confidence = await context.llm.generate({
        system: `You're a support agent. Can this ticket be resolved with the KB articles?
                 Return JSON: { canResolve: boolean, confidence: 0-100, response: string }`,
        prompt: `Ticket: ${ticket.description}
                 KB Articles: ${JSON.stringify(kbResults)}`,
        responseFormat: 'json'
      });
      
      const analysis = JSON.parse(confidence);
      
      if (analysis.canResolve && analysis.confidence > 85) {
        // Auto-respond and close
        await context.api.call('zendesk', {
          endpoint: `/tickets/${ticket.id}`,
          method: 'PUT',
          data: {
            status: 'solved',
            comment: {
              body: analysis.response,
              public: true
            }
          }
        });
      } else {
        // Add context for human agent
        await context.api.call('zendesk', {
          endpoint: `/tickets/${ticket.id}`,
          method: 'PUT',
          data: {
            comment: {
              body: `AI Suggested Response (${analysis.confidence}% confidence):\n\n${analysis.response}`,
              public: false
            },
            tags: ['ai-reviewed', `confidence-${Math.floor(analysis.confidence / 10) * 10}`]
          }
        });
      }
    }
    
    return { processed: tickets.length };
  }
};

# ~/.openclaw/config/security.yaml
security:
  # Require approval for high-risk actions
  require_approval:
    - send_email
    - execute_shell_command
    - modify_files
    
  # Budget controls
  daily_api_limit: 10.00  # USD
  
  # Network restrictions
  allowed_domains:
    - "api.anthropic.com"
    - "api.openai.com"
    - "your-approved-apis.com"
    
  # Audit logging
  log_all_actions: true
  log_retention_days: 90