One post tagged with "demos"

async function gatherDemoContext(dealId) {
  // CRM data
  const deal = await crm.getDeal(dealId);
  const company = await crm.getCompany(deal.companyId);
  const contacts = await crm.getContacts(deal.contactIds);
  
  // Meeting history
  const meetings = await crm.getMeetings(dealId);
  const discoveryNotes = meetings
    .filter(m => m.type === 'discovery')
    .map(m => m.notes)
    .join('\n');
  
  // Enrich with external data
  const companyNews = await newsApi.search({
    company: company.name,
    daysBack: 30
  });
  
  const industryTrends = await getIndustryInsights(company.industry);
  
  // Find relevant case studies
  const relevantCaseStudies = await caseStudyDb.find({
    industry: company.industry,
    size: company.employeeRange,
    useCase: deal.primaryUseCase
  });
  
  // Get competitor intel
  const competitorMentions = extractCompetitors(discoveryNotes);
  const competitorIntel = await getCompetitorBattlecards(competitorMentions);
  
  return {
    company,
    contacts,
    deal,
    discoveryNotes,
    companyNews,
    industryTrends,
    caseStudies: relevantCaseStudies,
    competitors: competitorIntel
  };
}

const { OpenAI } = require('openai');
const codex = new OpenAI({ model: 'gpt-5.3-codex' });

async function generateDemoScript(context) {
  const response = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `You are an expert sales demo strategist. Generate a 
personalized demo script that will resonate with this specific prospect.

DEMO STRUCTURE:
1. Personalized Opening (2 min) - Reference their world
2. Pain Validation (3 min) - Confirm what you heard in discovery  
3. Priority Feature #1 (10 min) - What they care most about
4. Priority Feature #2 (8 min) - Second most relevant
5. Integration/Workflow (5 min) - How it fits their stack
6. Social Proof (3 min) - Case study from similar company
7. Pricing Context (2 min) - Frame value, not cost
8. Next Steps (2 min) - Clear path forward

OUTPUT FORMAT:
- Include speaker notes for each section
- Add talk tracks for common objections
- Include specific data points to mention
- Flag areas needing live customization`
      },
      {
        role: 'user',
        content: `Create a demo script for this opportunity:

COMPANY: ${context.company.name}
INDUSTRY: ${context.company.industry}
SIZE: ${context.company.employeeCount} employees
REVENUE: $${context.company.revenue}M

DISCOVERY INSIGHTS:
${context.discoveryNotes}

KEY PAIN POINTS IDENTIFIED:
${extractPainPoints(context.discoveryNotes).join('\n- ')}

RECENT COMPANY NEWS:
${context.companyNews.map(n => `- ${n.headline}`).join('\n')}

RELEVANT CASE STUDY:
${JSON.stringify(context.caseStudies[0])}

COMPETITORS MENTIONED:
${context.competitors.map(c => c.name).join(', ')}

Generate a complete, personalized demo script.`
      }
    ],
    max_tokens: 4000,
    response_format: { type: 'json_object' }
  });
  
  return JSON.parse(response.choices[0].message.content);
}

async function customizeSlideDeck(masterDeck, context, demoScript) {
  // Parse the master deck (Google Slides, PowerPoint, etc.)
  const slides = await parseDeck(masterDeck);
  
  const customizations = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `You are customizing a sales demo deck. For each slide,
determine what changes are needed for this specific prospect.

Types of customizations:
1. TEXT_REPLACE - Swap placeholder text
2. REORDER - Move slide to different position
3. SKIP - Mark slide to hide
4. ADD_DATA - Insert prospect-specific data
5. CASE_STUDY_SWAP - Replace case study content`
      },
      {
        role: 'user',
        content: `MASTER DECK SLIDES:
${slides.map((s, i) => `[${i}] ${s.title}: ${s.content.substring(0, 200)}`).join('\n')}

PROSPECT CONTEXT:
Company: ${context.company.name}
Industry: ${context.company.industry}
Pain Points: ${extractPainPoints(context.discoveryNotes).join(', ')}

DEMO SCRIPT FLOW:
${demoScript.sections.map(s => s.title).join(' → ')}

RELEVANT CASE STUDY:
${JSON.stringify(context.caseStudies[0])}

Output a JSON array of customization instructions.`
      }
    ]
  });
  
  // Apply customizations
  const customizedDeck = applyCustomizations(slides, customizations);
  
  return customizedDeck;
}

async function generateObjectionHandlers(context) {
  const handlers = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `Generate objection handling scripts specific to this 
prospect's context. Include:
- The likely objection based on their situation
- Why they might raise it
- Data-backed response
- Reframe to positive

Be specific, not generic.`
      },
      {
        role: 'user',
        content: `PROSPECT CONTEXT:
Industry: ${context.company.industry}
Company Size: ${context.company.employeeCount}
Current Tools: ${context.deal.currentSolution}
Budget Range: ${context.deal.budget}
Competitors Evaluating: ${context.competitors.map(c => c.name).join(', ')}

DISCOVERY CONCERNS:
${extractConcerns(context.discoveryNotes).join('\n')}

Generate 5 likely objections with tailored responses.`
      }
    ]
  });
  
  return handlers.choices[0].message.content;
}

// Start generation
const stream = codex.chat.completions.create({
  model: 'gpt-5.3-codex',
  messages: [...],
  stream: true
});

// Monitor and steer mid-generation
for await (const chunk of stream) {
  const partialOutput = chunk.choices[0].delta.content;
  
  // If going off-track, inject steering
  if (partialOutput.includes('generic feature list')) {
    await stream.steer({
      instruction: 'Focus on manufacturing-specific capabilities only'
    });
  }
}

// Trigger 2 hours before scheduled demo
cron.schedule('0 */1 * * *', async () => {
  const upcomingDemos = await calendar.getDemos({
    timeWindow: '2-3 hours from now'
  });
  
  for (const demo of upcomingDemos) {
    const context = await gatherDemoContext(demo.dealId);
    const script = await generateDemoScript(context);
    const deck = await customizeSlideDeck(MASTER_DECK, context, script);
    const handlers = await generateObjectionHandlers(context);
    
    // Send prep package to AE
    await slack.sendDM(demo.ownerId, {
      text: `🎯 Demo prep ready for ${context.company.name} in 2 hours`,
      attachments: [
        { title: 'Personalized Script', content: script },
        { title: 'Custom Deck', url: deck.url },
        { title: 'Objection Handlers', content: handlers }
      ]
    });
  }
});

// After demo ends, generate follow-up
async function postDemoAutomation(demoId, demoNotes) {
  const context = await gatherDemoContext(demoId);
  
  // Generate personalized follow-up based on what happened
  const followUp = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [{
      role: 'user',
      content: `Based on this demo, generate follow-up:

DEMO NOTES:
${demoNotes}

ORIGINAL CONTEXT:
${JSON.stringify(context)}

Generate:
1. Follow-up email addressing specific questions raised
2. Relevant resources to send
3. Suggested next step with timeline`
    }]
  });
  
  return followUp;
}