Chatbots wait for you to ask. Proactive AI acts before you even realize you need it.

This isn't a philosophical distinction—it's an architectural one. Let's build both and compare.

The Chatbot Architecture

Classic chatbot (ChatGPT, Claude, etc.):

User Input → LLM → Response → Display

Simple. Effective. Completely reactive.

You ask, it answers. That's it.

The Code

async function chatbotResponse(userMessage: string): Promise<string> {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: userMessage }
    ],
  });

  return response.choices[0].message.content;
}

Problem: This only works when the user initiates. It can't:

Monitor external events
Trigger actions based on conditions
Alert users proactively

The Proactive AI Architecture

Proactive AI watches the world and acts when conditions are met:

External Event → Condition Check → Agent Decision → Action (Alert/Execute)

The user doesn't prompt it. It prompts the user.

Example: Price Drop Agent

// Background job running every hour
async function priceMonitorAgent() {
  // Get all watched products
  const products = await db.product.findMany({
    where: { monitoring: true }
  });

  for (const product of products) {
    // Fetch current price
    const currentPrice = await fetchPrice(product.asin);

    // Decision logic
    if (shouldAlert(product, currentPrice)) {
      // Proactive action: call the user
      await alertUser(product.user, {
        product: product.name,
        oldPrice: product.lastPrice,
        newPrice: currentPrice,
        savings: product.lastPrice - currentPrice,
      });

      // Update state
      await db.product.update({
        where: { id: product.id },
        data: { lastPrice: currentPrice }
      });
    }
  }
}

function shouldAlert(product: Product, currentPrice: number): boolean {
  // Agent decides based on:
  // 1. User preferences (persona)
  // 2. Historical patterns
  // 3. Predicted trends

  const priceDrop = ((product.lastPrice - currentPrice) / product.lastPrice) * 100;

  // Deal Hunter: alert on any 10%+ drop
  if (product.persona === "DEAL_HUNTER" && priceDrop >= 10) {
    return true;
  }

  // Patience Pro: alert on 30%+ drop
  if (product.persona === "PATIENCE_PRO" && priceDrop >= 30) {
    return true;
  }

  // Predicted minimum approaching?
  const forecast = predictPrice(product.history);
  const nearMinimum = currentPrice <= forecast.predictedMin * 1.05;

  return nearMinimum;
}

Key difference: The agent monitors continuously and decides when to act.

Why This Matters

Chatbot Workflow

User opens app
User types: "Did the price drop?"
Bot checks and responds
Problem: User has to remember to check

Proactive AI Workflow

Price drops
AI calls user: "Price dropped to $299"
User decides to buy
Result: Zero cognitive load

Building Proactive AI: The Architecture

Here's how we structure Autonomy products:

1. Event Monitoring Layer

// Cron job (Vercel Cron)
export const config = {
  runtime: 'edge',
  // Runs every hour
  schedule: '0 * * * *',
};

export default async function monitorEvents(req: Request) {
  // Check all active monitors
  const monitors = await getActiveMonitors();

  await Promise.all(
    monitors.map(monitor => evaluateConditions(monitor))
  );

  return new Response('OK');
}

2. Decision Engine

async function evaluateConditions(monitor: Monitor) {
  // Fetch current state
  const currentState = await fetchState(monitor.target);

  // Use LLM for complex decisions
  const decision = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{
      role: "system",
      content: `You are a proactive AI agent monitoring ${monitor.type}.
                Current state: ${JSON.stringify(currentState)}
                User preferences: ${JSON.stringify(monitor.preferences)}
                Should you alert the user? Respond with YES or NO and reasoning.`
    }],
    temperature: 0, // Deterministic
  });

  if (decision.content.startsWith("YES")) {
    await triggerAction(monitor, currentState);
  }
}

3. Action Layer

async function triggerAction(monitor: Monitor, state: any) {
  switch (monitor.actionType) {
    case "PHONE_CALL":
      await callUser(monitor.userId, state);
      break;
    case "SMS":
      await sendSMS(monitor.userId, state);
      break;
    case "EMAIL":
      await sendEmail(monitor.userId, state);
      break;
    case "EXECUTE":
      // Autonomous execution (e.g., book appointment)
      await executeAction(monitor.action, state);
      break;
  }

  // Log for analytics
  await logAction(monitor, state);
}

The Technical Challenges

1. State Management

Proactive AI needs to remember context across sessions.

interface AgentState {
  lastCheck: Date;
  lastAlert: Date;
  userResponded: boolean;
  conditionsMet: number; // Prevent spam
  context: Record<string, any>;
}

2. Rate Limiting

Don't alert users every 5 minutes. Be smart about timing.

function canAlert(monitor: Monitor): boolean {
  const hoursSinceLastAlert =
    (Date.now() - monitor.lastAlert.getTime()) / (1000 * 60 * 60);

  // Wait at least 24 hours between similar alerts
  if (hoursSinceLastAlert < 24) {
    return false;
  }

  return true;
}

3. False Positives

Over-alerting kills trust. Tune thresholds carefully.

We use a confidence score:

interface AlertDecision {
  shouldAlert: boolean;
  confidence: number; // 0-100
  reasoning: string;
}

// Only alert if confidence > 80%
if (decision.confidence > 80) {
  await alert(user);
}

Real-World Examples

Autonomy Receptionist

Reactive bot: "Ask me about our hours" Proactive agent: Answers phone calls autonomously, books appointments, routes to humans when needed

Autonomy PricePulse

Reactive bot: "Check if price dropped" Proactive agent: Monitors 24/7, calls you when it's time to buy

The ROI of Proactive AI

Chatbot engagement: 3-5% daily active users Proactive AI engagement: 60-70% response rate to alerts

Why? Because you're solving the problem before they even know they have it.

How to Build Your Own

Identify the event (price change, call received, appointment time)
Define conditions (when should AI act?)
Choose action (alert, execute, escalate)
Monitor & tune (reduce false positives over time)

Starter Template

// 1. Monitor (cron job)
export async function monitoringAgent() {
  const users = await getActiveUsers();

  for (const user of users) {
    const event = await checkForEvent(user);

    if (event && meetsConditions(event, user.preferences)) {
      await takeAction(user, event);
    }
  }
}

// 2. Decision
function meetsConditions(event: Event, prefs: UserPrefs): boolean {
  // Your logic here
  return event.value > prefs.threshold;
}

// 3. Action
async function takeAction(user: User, event: Event) {
  await notifyUser(user, `Event detected: ${event.description}`);
}

The Future

Today: Proactive AI monitors and alerts.

Tomorrow: Proactive AI executes autonomously.

Imagine:

Your AI receptionist automatically booking appointments (no human approval)
Your price agent automatically purchasing products (within budget)
Your scheduling agent automatically declining meetings (based on your preferences)

That's the endgame. Full autonomy.

See proactive AI in action: Autonomy Receptionist | PricePulse