Documentation

A support ticket agent that classifies, drafts responses, and escalates when uncertain

await mobius.run('support-agent', async (ctx) => {
  const ticket = ctx.input.ticket;

  // Step 1: Classify the ticket
  const classification = await ctx.step('classify', async () => {
    const result = await ai.classify(ticket.content, {
      categories: ['billing', 'technical', 'general', 'urgent']
    });
    return result;
  });

  // Step 2: Generate a draft response
  const draft = await ctx.step('draft-response', async () => {
    return await ai.generate({
      prompt: `Draft a response to: ${ticket.content}`,
      context: classification.category
    });
  });

  // Step 3: If confidence is low, escalate to human
  if (draft.confidence < 0.8) {
    const review = await ctx.prompt('review-draft', {
      type: 'review',
      message: 'AI drafted response needs review',
      data: {
        ticket: ticket.content,
        draft: draft.response,
        confidence: draft.confidence
      },
      outcomes: ['approve', 'edit', 'escalate']
    });

    if (review.outcome === 'escalate') {
      return await ctx.step('create-escalation', () =>
        createEscalation(ticket.id)
      );
    }
  }

  // Step 4: Send the response
  await ctx.step('send-response', async () => {
    return await sendEmail(ticket.email, draft.response);
  });

  return { status: 'resolved', ticketId: ticket.id };
})

Multi-stage expense approval with escalation and timeout handling

await mobius.run('expense-approval', async (ctx) => {
  const expense = ctx.input.expense;

  // Auto-approve small expenses
  if (expense.amount < 100) {
    return await ctx.step('auto-approve', () =>
      approveExpense(expense.id)
    );
  }

  // Manager approval for medium expenses
  const managerApproval = await ctx.prompt('manager-review', {
    type: 'review',
    message: `Approve expense: $${expense.amount}`,
    data: expense,
    outcomes: ['approve', 'deny'],
    assignee: expense.managerId,
    timeout: '48h'
  });

  if (managerApproval.outcome === 'deny') {
    return { status: 'denied', reason: managerApproval.reasoning };
  }

  // VP approval for large expenses
  if (expense.amount > 1000) {
    const vpApproval = await ctx.prompt('vp-review', {
      type: 'review',
      message: `VP approval needed: $${expense.amount}`,
      data: { ...expense, managerApproval },
      outcomes: ['approve', 'deny'],
      timeout: '72h'
    });

    if (vpApproval.outcome === 'deny') {
      return { status: 'denied', reason: vpApproval.reasoning };
    }
  }

  // Process the reimbursement
  const payment = await ctx.step('process-payment', () =>
    processReimbursement(expense),
    { retry: { maxAttempts: 3 } }
  );

  return { status: 'approved', paymentId: payment.id };
})

Process thousands of documents with retries, parallel execution, and human review

await mobius.run('document-pipeline', async (ctx) => {
  const documents = ctx.input.documents; // Array of doc URLs

  // Process documents in parallel (batches of 10)
  const results = await ctx.step('process-batch', async () => {
    const batches = chunk(documents, 10);
    const processed = [];

    for (const batch of batches) {
      const batchResults = await ctx.parallel(
        batch.map((doc, i) =>
          ctx.step(`extract-${i}`, () => extractData(doc), {
            retry: { maxAttempts: 3, backoff: 'exponential' }
          })
        )
      );
      processed.push(...batchResults);
    }
    return processed;
  });

  // Flag ambiguous extractions for human review
  const needsReview = results.filter(r => r.confidence < 0.9);

  if (needsReview.length > 0) {
    const reviewed = await ctx.prompt('review-extractions', {
      type: 'form',
      message: `Review ${needsReview.length} uncertain extractions`,
      fields: needsReview.map(r => ({
        name: r.documentId,
        type: 'text',
        label: `Value for ${r.field}`,
        defaultValue: r.extractedValue
      }))
    });

    // Merge reviewed values
    for (const [docId, value] of Object.entries(reviewed.values)) {
      const idx = results.findIndex(r => r.documentId === docId);
      results[idx].extractedValue = value;
      results[idx].humanReviewed = true;
    }
  }

  // Load to destination
  await ctx.step('load-results', () =>
    loadToDatabase(results),
    { retry: { maxAttempts: 3 } }
  );

  return {
    processed: results.length,
    reviewed: needsReview.length,
    status: 'complete'
  };
})