AutoGineer
Generated banner for Zoom General
Generated logo for Zoom General

Zoom General

OpenAIOfficialCreated by ZoomDistributed by OpenAI

  • Skill
  • Tool integration
  • Automation and integrations
  • MIT
  • Medium risk
Download ZIP

From the author

Use when comparing products.
— the description by Zoom

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Zoom General serves as a strategic starting point for developers and architects to navigate the Zoom ecosystem. It provides a structured workflow to classify integration requirements, identify the correct Zoom product surface (such as APIs, SDKs, or webhooks), and determine the necessary authentication model. By guiding users through a decision-making process, it ensures that developers select the right tool for their specific use case before routing to more specialized skills.

What it does

  • Classifies integration jobs based on desired outcomes like embedding meetings or automating resources.
  • Maps requirements to specific Zoom surfaces including REST APIs, WebSockets, and various SDKs.
  • Provides guidance on selecting the correct authentication and scope model for an integration.
  • Facilitates routing to specialized skills once the product context is established.
  • Offers comparative context for tasks that span multiple Zoom product boundaries.

When to use it

  • When you are in the early stages of planning a Zoom integration and need to choose the right app type.
  • When you need to compare different Zoom surfaces to determine which fits your technical requirements.
  • When a task involves multiple Zoom products and requires a high-level architectural approach.
  • When you need to confirm the correct authentication flow for a specific integration scenario.

Advantages

  • Prevents premature selection of tools by enforcing a structured classification process.
  • Clarifies the distinction between user-level OAuth, account-level OAuth, and SDK signatures.
  • Reduces complexity by routing users to narrow, specialized skills after initial planning.
  • Provides a clear decision matrix for choosing between General Apps, Server-to-Server OAuth, and Webhook Only apps.

Usage examples

“I want to build an app that automates meeting reports. Which Zoom app type should I use?”
The agent will guide you to classify the job as backend automation, leading to the recommendation of Server-to-Server OAuth for its lack of user interaction requirements.
“Should I use the Meeting SDK or the Video SDK for my project?”
The agent will help you compare the two based on your specific embedding needs and surface requirements, ensuring you choose the correct SDK for your use case.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/openai/zoom-general/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip zoom-general.zip -d .agents/skills

Documentation by Zoom

Zoom General

Use this skill for cross-product platform context after the user’s goal is understood. For first-step routing, prefer start, plan-zoom-product, or plan-zoom-integration.

Workflow

  1. Classify the job by outcome: embed meetings, custom video, automate resources, consume events, process media, use meeting intelligence, or publish a Marketplace app.

  2. Choose the Zoom surface that owns the behavior: REST API, webhooks, WebSockets, Meeting SDK, Video SDK, Zoom Apps SDK, Phone, Contact Center, Virtual Agent, Scribe, Rivet, or Cobrowse.

  3. Confirm auth and scope model before implementation; Zoom surfaces differ on user-level OAuth, account-level OAuth, and SDK signatures.

  4. Route to the narrow skill once the surface is chosen rather than keeping broad guidance in context.

  5. Use the preserved guide only when a task crosses product boundaries or needs detailed comparison tables.

References

Files

use-cases/form-completion-assistant.md

Form Completion Assistant with Co-Browsing

Guide customers through complex forms in real-time using visual assistance and privacy-protected co-browsing.

Use Case Overview

Problem: High form abandonment rates due to complexity, confusion, or lack of confidence in data entry.

Solution: Implement Zoom Cobrowse SDK to provide real-time visual guidance while protecting sensitive customer data through privacy masking.

Related Skills:

Target Scenarios

Financial Services

  • Loan applications

  • Account opening forms

  • Investment questionnaires

  • Insurance claims

Healthcare

  • Patient intake forms

  • Insurance enrollment

  • Medical history questionnaires

  • Telehealth registration

E-Commerce

  • Complex checkout flows

  • B2B order forms

  • Subscription sign-ups

  • Custom product configurators

Implementation

Quick Start Pattern
<!DOCTYPE html>
<html>
<head>
  <title>Loan Application - Form Assistant</title>
  <script type="module">
    const ZOOM_SDK_KEY = 'YOUR_SDK_KEY';

    // Load Cobrowse SDK
    (function(r, a, b, f, c, d) {
      r[f] = r[f] || { init: function() { r.ZoomCobrowseSDKInitArgs = arguments }};
      var fragment = a.createDocumentFragment();
      function loadJs(url) {
        c = a.createElement(b);
        d = a.getElementsByTagName(b)[0];
        c["async"] = false;
        c.src = url;
        fragment.appendChild(c);
      }
      loadJs(`https://us01-zcb.zoom.us/static/resource/sdk/${ZOOM_SDK_KEY}/js/2.13.2`);
      d.parentNode.insertBefore(fragment, d);
    })(window, document, "script", "ZoomCobrowseSDK");
  </script>
</head>
<body>
  <div class="form-header">
    <h1>Loan Application</h1>
    <button id="help-btn">Need Help Completing This Form?</button>
  </div>

  <form id="loan-application">
    <!-- Step 1: Personal Information -->
    <section class="form-step" data-step="1">
      <h2>Personal Information</h2>
      <input name="firstName" placeholder="First Name" required>
      <input name="lastName" placeholder="Last Name" required>
      <input name="email" type="email" placeholder="Email" required>
      <input name="phone" type="tel" placeholder="Phone Number" required>
    </section>

    <!-- Step 2: Sensitive Information (MASKED) -->
    <section class="form-step" data-step="2">
      <h2>Identification</h2>
      <input name="ssn" class="pii-mask" placeholder="SSN"
             pattern="[0-9]{3}-[0-9]{2}-[0-9]{4}">
      <small>🔒 This field is hidden from support agents</small>

      <input name="dob" class="pii-mask" type="date" placeholder="Date of Birth">
      <small>🔒 This field is hidden from support agents</small>
    </section>

    <!-- Step 3: Financial Information (PARTIALLY MASKED) -->
    <section class="form-step" data-step="3">
      <h2>Financial Information</h2>
      <input name="income" type="number" placeholder="Annual Income">
      <input name="employer" placeholder="Employer Name">

      <input name="accountNumber" class="pii-mask" placeholder="Bank Account Number">
      <small>🔒 This field is hidden from support agents</small>

      <input name="routingNumber" class="pii-mask" placeholder="Routing Number">
      <small>🔒 This field is hidden from support agents</small>
    </section>

    <!-- Step 4: Loan Details -->
    <section class="form-step" data-step="4">
      <h2>Loan Request</h2>
      <input name="loanAmount" type="number" placeholder="Requested Amount">
      <select name="loanPurpose">
        <option value="">Select Purpose</option>
        <option value="home">Home Purchase</option>
        <option value="auto">Auto Purchase</option>
        <option value="personal">Personal</option>
      </select>
    </section>
  </form>

  <div id="help-widget" style="display:none;">
    <p>Share this PIN with your support agent:</p>
    <div id="pin-code"></div>
    <button id="end-session">End Assistance</button>
  </div>

  <script>
    let sessionRef = null;
    let currentStep = 1;

    const settings = {
      allowAgentAnnotation: true,     // Agent can highlight fields
      allowCustomerAnnotation: false,
      piiMask: {
        maskType: "custom_input",
        maskCssSelectors: ".pii-mask"  // Hide sensitive fields
      }
    };

    ZoomCobrowseSDK.init(settings, function({ success, session, error }) {
      if (success) {
        sessionRef = session;

        session.on("pincode_updated", (payload) => {
          document.getElementById("pin-code").innerText = payload.pincode;
          document.getElementById("help-widget").style.display = "block";

          // Optional: Auto-dial support or show phone number
          showSupportContact(payload.pincode);
        });

        session.on("agent_joined", () => {
          showBanner("Support agent is now helping you");
          trackEvent("form_assistance_started");
        });

        session.on("agent_left", () => {
          showBanner("Support agent has left");
          trackEvent("form_assistance_ended");
        });
      }
    });

    // Help button handler
    document.getElementById("help-btn").addEventListener("click", async () => {
      const response = await fetch("/api/form-assistance-token", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          role: 1,
          formType: "loan_application",
          currentStep: currentStep,
          userId: getOrCreateUserId()
        })
      });

      const { token } = await response.json();
      sessionRef.start({ sdkToken: token });

      // Track that user requested help
      trackEvent("form_help_requested", {
        formType: "loan_application",
        step: currentStep
      });
    });

    // End session handler
    document.getElementById("end-session").addEventListener("click", () => {
      if (sessionRef) {
        sessionRef.end();
        document.getElementById("help-widget").style.display = "none";
      }
    });

    // Track form completion
    document.getElementById("loan-application").addEventListener("submit", (e) => {
      e.preventDefault();

      trackEvent("form_completed", {
        hadAssistance: sessionRef !== null,
        steps: currentStep
      });

      submitForm();
    });
  </script>
</body>
</html>

Key Features

Progressive Privacy Masking

Mask fields based on sensitivity level:

// Tier 1: Fully masked (never visible to agent)
// - SSN, passwords, credit cards
const tier1Fields = ".pii-mask, [data-privacy='full']";

// Tier 2: Masked by default, can be unmasked with consent
// - Bank account numbers, tax IDs
const tier2Fields = "[data-privacy='optional']";

const settings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: tier1Fields,
  }
};
Smart Annotation Guidance

Agent can highlight and guide:

<!-- Agent's view shows annotations -->
<style>
  /* Agent's annotation appears on customer's screen */
  .agent-highlight {
    border: 2px solid #0e72ed;
    box-shadow: 0 0 8px rgba(14, 114, 237, 0.6);
  }
</style>
Real-Time Validation Assistance

Agent sees validation errors in real-time:

// Show validation status to agent
form.addEventListener("blur", (e) => {
  if (e.target.validity.valid) {
    e.target.classList.add("valid");
  } else {
    e.target.classList.add("invalid");
    // Agent can see this and provide guidance
  }
}, true);

Workflow Example

Multi-Step Form Assistance
CUSTOMER                           AGENT
   │                                 │
   │  1. Opens loan application      │
   │     (Step 1 of 4)               │
   │                                 │
   │  2. Confused at Step 2          │
   │  Clicks "Need Help?"            │
   ├────────► Request Help           │
   │          (PIN: 123456)          │
   │                                 │
   │  3. Calls support               │
   │     "I need help with           │
   │      loan application"          │
   │                                 │
   │                                 │  4. Agent opens case
   │                                 │     Enters PIN: 123456
   │                                 │
   │  ◄─────── Agent Joined ─────────┤
   │                                 │
   │  5. Agent sees form (Step 2)    │
   │     Masked fields: SSN, DOB     │
   │     Visible: Everything else    │
   │                                 │
   │                                 │  6. Agent uses pen tool
   │  ◄────── Highlight field ───────┤     Highlights "SSN"
   │                                 │     Says: "Enter your SSN"
   │                                 │
   │  7. Enters SSN                  │
   │     (Agent sees: ***-**-****)   │
   │                                 │
   │                                 │  8. Agent highlights next
   │  ◄────── Highlight DOB ─────────┤     "Now your date of birth"
   │                                 │
   │  9. Completes Step 2            │
   │     Moves to Step 3             │
   │                                 │
   │  10. Finishes form              │
   │  ─────► Form Submitted ─────────►
   │                                 │
   │  11. Thanks agent               │
   │  ◄────── Session Ends ──────────┤

Privacy Protection Patterns

Pattern 1: Full Masking (Recommended)
// All sensitive fields completely hidden
const settings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: ".pii-mask, .sensitive, [data-private]"
  }
};

Use for: SSN, passwords, credit cards, medical records

Pattern 2: Partial Masking
// Show last 4 digits (not natively supported, requires custom implementation)
function partialMask(value) {
  return '*'.repeat(value.length - 4) + value.slice(-4);
}

Use for: Phone numbers (show area code), account numbers

Pattern 3: Contextual Masking
// Mask based on form section
function updateMasking(stepNumber) {
  const maskingRules = {
    1: ".none",              // No masking on basic info
    2: ".ssn, .dob",         // Mask ID fields
    3: ".account, .routing", // Mask financial fields
    4: ".none"               // No masking on loan details
  };

  // Update SDK settings dynamically
  // Note: Requires re-initialization in current SDK version
}

Analytics and Tracking

Measure Assistance Effectiveness
// Track form completion with/without assistance
const metrics = {
  formType: "loan_application",
  assistanceRequested: true,
  assistanceDuration: 420, // seconds
  stepWhereHelpRequested: 2,
  completionRate: 1,       // 1 = completed, 0 = abandoned
  timeToComplete: 1200,    // seconds
  fieldsModified: 18,
  validationErrors: 2
};

analytics.track("form_completion", metrics);
Key Metrics to Track

  1. Form Abandonment Rate

    • Before assistance: 35%

    • With assistance: 8%

    • 73% improvement

  2. Time to Complete

    • Without assistance: 15 min avg

    • With assistance: 8 min avg

    • 47% faster

  3. Error Rate

    • Without assistance: 3.2 errors/form

    • With assistance: 0.8 errors/form

    • 75% fewer errors

  4. Customer Satisfaction

    • CSAT score: 4.7/5

    • NPS: +68

Integration Examples

Salesforce Integration
// Log form assistance session to Salesforce
async function logFormAssistance(leadId, sessionData) {
  await salesforce.leads.update(leadId, {
    Form_Assistance_Date__c: new Date(),
    Assistance_Duration__c: sessionData.duration,
    Form_Completed__c: sessionData.completed,
    Agent_Id__c: sessionData.agentId
  });
}
HubSpot Integration
// Create activity for form assistance
await hubspot.contacts.createActivity(contactId, {
  type: "cobrowse_assistance",
  timestamp: Date.now(),
  properties: {
    form_type: "loan_application",
    duration: sessionDuration,
    completed: formCompleted
  }
});

Best Practices

1. Clear Help Triggers

Place help buttons strategically:

  • Top of form (always visible)

  • Beginning of each complex section

  • Near confusing field labels

2. Privacy First

  • Mask by default, unmask only if absolutely necessary

  • Show clear indicators when fields are masked

  • Get consent before starting session

3. Progress Preservation
// Save form state before assistance
function saveFormState() {
  const formData = new FormData(document.getElementById("loan-application"));
  localStorage.setItem("form_draft", JSON.stringify(Object.fromEntries(formData)));
}

// Restore on page reload
function restoreFormState() {
  const saved = localStorage.getItem("form_draft");
  if (saved) {
    const data = JSON.parse(saved);
    Object.entries(data).forEach(([name, value]) => {
      const field = document.querySelector(`[name="${name}"]`);
      if (field) field.value = value;
    });
  }
}
4. Agent Training

Train agents on:

  • Which fields are masked vs visible

  • How to use annotation tools effectively

  • When to suggest breaks for complex forms

  • Privacy compliance requirements

Common Challenges & Solutions

Challenge: Customer refreshes page during assistance Solution: Implement auto-reconnection (see Auto-Reconnection Guide)

Challenge: Agent can't see validation errors Solution: Add visual indicators that aren't masked:

field.parentElement.classList.add("has-error");

Challenge: Multi-page forms lose session Solution: Use session persistence across page navigation:

const settings = {
  multiTabSessionPersistence: {
    enable: true
  }
};

Cost-Benefit Analysis

Costs

  • Zoom SDK: ~$0.05 per assistance minute

  • Development: 2-3 weeks integration

  • Agent Training: 4 hours per agent

Benefits

  • Reduced Abandonment: 35% → 8% = 27% more conversions

  • Faster Completion: 15 min → 8 min = 47% time saved

  • Fewer Errors: 75% reduction in submission errors

  • Higher CSAT: 4.7/5 satisfaction score

ROI Example (1000 forms/month):

  • Before: 650 completed (35% abandoned)

  • After: 920 completed (8% abandoned)

  • Additional conversions: 270/month

  • Avg value/conversion: $50

  • Additional revenue: $13,500/month

  • SDK cost: ~$500/month

  • Net benefit: $13,000/month

Related Resources

Next Steps

  1. Identify high-abandon forms in your application

  2. Review privacy requirements for your industry

  3. Set up auth server using JWT Authentication

  4. Integrate customer SDK using Customer Integration

  5. Train support agents on co-browsing and privacy controls

  6. Measure results and iterate based on analytics

Requirements and compatibility

Written for: OpenAI Codex

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

  • Possible data-exfiltration endpoints
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Zoom
Publisher
OpenAI (Official)
Distributed by
OpenAI
Source
openai/plugins · plugins/zoom/skills/general · commit d420d13
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from plugins/zoom/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Zoom or OpenAI.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download zoom-general.zip