Phase 3: Intelligence

Make the agent proactive and smart.

Timeline: Q3 2026 (10-12 weeks) Goal: Agent that works while you sleep

---

The Shift

Phase 1-2: Agent responds to commands Phase 3: Agent acts autonomously

Before: "Find me a job" → Agent searches
After:  Agent finds job at 2AM → Applies → Notifies you at 7AM

---

3.1 Proactive Agent

What We're Building

Capability	Description
Background Job Matching	Continuously match users to new jobs
Price Alerts	Watch items, notify on price drops
Inventory Suggestions	Suggest what to source based on demand
Auto Follow-ups	Chase invoices, nudge buyers
Opportunity Detection	Spot patterns, suggest actions

Technical Spec

Proactive Task System

-- User preferences for proactive actions
proactive_settings (
  user_id UUID,
  job_alerts BOOLEAN DEFAULT true,
  price_alerts BOOLEAN DEFAULT true,
  auto_apply BOOLEAN DEFAULT false,  -- Opt-in
  quiet_hours_start TIME,
  quiet_hours_end TIME
)

-- Scheduled tasks
agent_tasks (
  id UUID,
  user_id UUID,
  task_type VARCHAR(50),  -- job_match, price_watch, follow_up
  config JSONB,
  next_run TIMESTAMP,
  last_run TIMESTAMP,
  status VARCHAR(20)
)

-- Task results
agent_actions (
  id UUID,
  user_id UUID,
  task_id UUID,
  action_type VARCHAR(50),  -- applied, alerted, followed_up
  details JSONB,
  created_at TIMESTAMP,
  notified_at TIMESTAMP
)

Background Job Matching

// Runs every hour
async function matchNewJobs() {
  // Get users with job alerts enabled
  const users = await getActiveJobSeekers();
  
  for (const user of users) {
    // Get jobs posted since last run
    const newJobs = await getNewJobs(user.lastJobCheck);
    
    // Score each job
    const matches = newJobs
      .map(job => ({
        job,
        score: calculateMatchScore(user, job)
      }))
      .filter(m => m.score >= user.minMatchScore)
      .sort((a, b) => b.score - a.score);
    
    if (matches.length > 0) {
      if (user.autoApply) {
        // Apply automatically
        for (const match of matches.slice(0, 5)) {
          await autoApply(user.id, match.job.id);
        }
        await notify(user.id, `Applied to ${matches.length} new jobs`);
      } else {
        // Just notify
        await notify(user.id, `${matches.length} new jobs match your profile`);
      }
    }
    
    await updateLastJobCheck(user.id);
  }
}

Price Watching

// User watches an item
async function watchItem(userId, listingId, targetPrice) {
  await db.priceWatches.create({
    userId,
    listingId,
    targetPrice,
    currentPrice: listing.price,
    status: 'active'
  });
}

// Runs when prices change
async function checkPriceDrops(listingId, newPrice) {
  const watches = await db.priceWatches.find({
    listingId,
    targetPrice: { $gte: newPrice },
    status: 'active'
  });
  
  for (const watch of watches) {
    await notify(watch.userId, {
      type: 'price_drop',
      listing: listingId,
      oldPrice: watch.currentPrice,
      newPrice,
      message: `Price dropped to ${newPrice}! Only 3 left.`
    });
  }
}

Auto Follow-ups

// Run daily
async function autoFollowUp() {
  // Unpaid invoices > 3 days
  const overdueInvoices = await getOverdueInvoices(3);
  
  for (const invoice of overdueInvoices) {
    if (invoice.followUpCount < 3) {
      await sendFollowUp(invoice);
      await incrementFollowUpCount(invoice.id);
    }
  }
  
  // Unresponsive buyers > 24 hours
  const stalledConversations = await getStalledConversations(24);
  
  for (const convo of stalledConversations) {
    await sendNudge(convo);
  }
}

Timeline

Week	Tasks
1-2	Task scheduling infrastructure
3-4	Background job matching
5-6	Price alerts
7-8	Auto follow-ups
9-10	Opportunity detection

---

3.2 Multi-Product Flows

What We're Building

Connected workflows that span multiple products.

Sell → Source → Resell Flow

1. User sells phone cases successfully
   Agent detects: high demand, good margins
   
2. Agent suggests: "You sold 20 cases this month.
   Want me to source more from China?"
   
3. User: "Yes, find similar for under $2"
   
4. Agent (via YeboNa):
   → Finds 5 verified suppliers
   → Shows options with reviews
   → User selects supplier
   
5. Agent (via YeboSafe):
   → Creates escrow for order
   → Collects payment from user
   → Releases to supplier on shipment
   
6. Agent tracks shipment
   → Notifies on customs clearance
   → Notifies on delivery
   
7. Agent (via YeboShops):
   → Auto-lists new inventory
   → Sets prices based on last sales
   → Distributes via Eneza

Learn → Work → Earn Flow

1. User: "I want to make money with coding"

2. Agent analyzes job market:
   → Most in-demand: React, Node.js
   → Average salary: $X
   → Jobs available: Y
   
3. Agent suggests learning path:
   → "Start with JavaScript Basics (2 weeks)
   → Then React Fundamentals (3 weeks)
   → You'll qualify for X jobs"
   
4. User enrolls (YeboLearn)
   Agent tracks progress
   Sends reminders
   
5. User completes, gets certificate
   Skills auto-added to profile
   
6. Agent (YeboJobs):
   → Searches matching jobs
   → Auto-applies to 20 positions
   → Schedules interviews
   
7. User gets job
   Agent (YeboLink):
   → Helps with contract
   → Sets up invoicing
   → Collects payments

Technical Spec

Flow Engine

const flows = {
  'sell-source-resell': {
    trigger: { type: 'sales_threshold', count: 10 },
    steps: [
      { action: 'suggest_sourcing', product: 'yebona' },
      { action: 'create_order', product: 'yebona' },
      { action: 'create_escrow', product: 'yebosafe' },
      { action: 'track_shipment', product: 'yebona' },
      { action: 'auto_list', product: 'yeboshops' }
    ]
  },
  
  'learn-work-earn': {
    trigger: { type: 'user_goal', goal: 'make_money' },
    steps: [
      { action: 'analyze_market', product: 'yebojobs' },
      { action: 'suggest_courses', product: 'yebolearn' },
      { action: 'track_learning', product: 'yebolearn' },
      { action: 'update_skills', product: 'yebojobs' },
      { action: 'auto_apply', product: 'yebojobs' }
    ]
  }
};

async function executeFlow(flowId, userId, context) {
  const flow = flows[flowId];
  
  for (const step of flow.steps) {
    const result = await executeStep(step, userId, context);
    context = { ...context, ...result };
    
    // Check if user intervention needed
    if (result.needsConfirmation) {
      await pauseAndNotify(userId, result.question);
      return; // Will resume on user response
    }
  }
}

Timeline

Week	Tasks
1-2	Flow engine architecture
3-4	Sell-source-resell flow
5-6	Learn-work-earn flow
7-8	Cross-product data sync

---

3.3 Personalization

What We're Building

Agent that learns and adapts to each user.

User Model

{
  // Communication preferences
  preferredTimes: ['morning', 'evening'],
  responseStyle: 'concise', // or 'detailed'
  language: 'en',
  
  // Behavior patterns
  typicalPriceRange: { min: 500, max: 5000 },
  negotiationStyle: 'firm', // accepts first offer, negotiates, etc.
  responseSpeed: 'fast', // how quickly they reply
  
  // Interests
  categories: ['electronics', 'fashion'],
  skills: ['javascript', 'design'],
  goals: ['increase_sales', 'find_job'],
  
  // Performance
  sellThroughRate: 0.7,
  averageRating: 4.8,
  completionRate: 0.95
}

Learning System

// Update model on each interaction
async function learn(userId, event) {
  const model = await getUserModel(userId);
  
  switch (event.type) {
    case 'message_sent':
      model.preferredTimes = updateTimePreference(
        model.preferredTimes, 
        event.timestamp
      );
      break;
      
    case 'price_accepted':
      model.typicalPriceRange = updatePriceRange(
        model.typicalPriceRange,
        event.price
      );
      break;
      
    case 'negotiation_completed':
      model.negotiationStyle = analyzeNegotiation(
        event.offers,
        event.finalPrice
      );
      break;
  }
  
  await saveUserModel(userId, model);
}

Personalized Responses

async function formatResponse(userId, content) {
  const model = await getUserModel(userId);
  
  // Adjust detail level
  if (model.responseStyle === 'concise') {
    content = summarize(content);
  }
  
  // Adjust tone
  if (model.formality === 'casual') {
    content = casualize(content);
  }
  
  // Respect quiet hours
  if (isQuietHours(model)) {
    return queue(content, model.preferredTimes[0]);
  }
  
  return content;
}

Timeline

Week	Tasks
1-2	User model schema
3-4	Learning from interactions
5-6	Personalized responses
7-8	Timing optimization

---

Success Metrics

Metric	Target
Proactive actions/user/day	3+
Auto-apply acceptance rate	>30%
Price alert conversion	>10%
Multi-product flow completion	>50%
User satisfaction	>4.5/5

---

Phase 3 Exit Criteria

• [ ] Agent works proactively (not just reactively)
• [ ] Cross-product flows working
• [ ] Personalization noticeable
• [ ] Users report "it knows me"
• [ ] Measurable time savings

---

Next: Phase 4: Scale