Custom language operator examples

This guide provides ready-to-use custom language operator examples you can create directly using the API. Each example includes the full API request so you can copy, customize, and deploy.

Operator types

You can create custom language operators for both real-time and post-conversation use cases. To add operators to your intelligence configuration, see Define rules.

Real-time operators

Real-time operators analyze conversations as they happen. Use these for live agent assist, in-conversation guidance, and triggering automations based on conversation signals.

Post-conversation operators

Post-conversation operators analyze completed interactions. Use these for contact center QA, agent coaching, and sales workflow automation.

Upsell Opportunity Detection

Detects organic upsell opportunities during live conversations, recommends relevant offers to the agent, and tracks whether the agent completed the upsell.

This operator uses Conversation Memory to understand the customer's purchase history and preferences, and Enterprise Knowledge to reference current promotions and product catalog.

API request

Upsell Opportunity Detection

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Upsell Opportunity Detection",
16    description:
17      "Detects upsell opportunities and recommends relevant offers based on conversation context and customer history.",
18    prompt:
19      "Analyze this conversation for organic upsell opportunities. Consider the customer's expressed needs, pain points, and any openings where additional products or services would genuinely help them. If an opportunity exists, recommend a specific upsell and provide talk track guidance. Also determine if the agent has already attempted or completed an upsell.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        opportunityDetected: {
25          type: "boolean",
26        },
27        opportunityType: {
28          type: "string",
29        },
30        recommendedOffer: {
31          type: "string",
32        },
33        talkTrack: {
34          type: "string",
35        },
36        agentAttemptedUpsell: {
37          type: "boolean",
38        },
39        upsellOutcome: {
40          type: "string",
41          enum: [
42            "not_attempted",
43            "attempted_accepted",
44            "attempted_declined",
45            "pending",
46          ],
47        },
48      },
49    },
50    context: {
51      knowledge: {
52        enabled: true,
53      },
54    },
55  });
56
57  console.log(operator.id);
58}
59
60createOperator();

Sample result

The following shows the full OperatorResult response structure.

Sample result: Upsell Opportunity Detection

1{
2  "id": "intelligence_operatorresult_01k6fc25s7epm9qtk8rszbv3q5",
3  "accountId": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
4  "outputFormat": "JSON",
5  "intelligenceConfiguration": {
6    "id": "intelligence_configuration_01k6fc25s7epm9qtk8rszbv3q5",
7    "ruleId": "intelligence_configurationrule_01k6fc25s7epm9qtk8rszbv3q6",
8    "version": 1
9  },
10  "conversationId": "conv_conversation_01k1etk2y5f1y9fpe2epfdtvv2",
11  "operator": {
12    "id": "intelligence_operator_01k6fc25s7epm9qtk8rszbv3q5",
13    "version": 1
14  },
15  "dateCreated": "2026-01-17T14:32:00Z",
16  "executionDetails": {
17    "trigger": {
18      "on": "COMMUNICATION",
19      "timestamp": "2026-01-17T14:31:58Z"
20    },
21    "communications": {
22      "first": "conv_communication_01k1etk2y5f1y9fpe2epfdtvv2",
23      "last": "conv_communication_01k1etk2y5f1y9fpe2epfdtvv3"
24    },
25    "channels": ["voice"],
26    "participants": [
27      {
28        "id": "conv_participant_01k1etx3jbfx88476ccja0889c",
29        "profileId": "mem_profile_01k1etx3jbfx88476ccja0889d",
30        "type": "CUSTOMER"
31      },
32      {
33        "id": "conv_participant_01k1etx3jbfx88476ccja0889e",
34        "type": "HUMAN_AGENT"
35      }
36    ],
37    "context": {
38      "customerMemory": {
39        "enabled": true
40      },
41      "knowledge": {
42        "bases": ["knowledge_base_01k1etx3jbfx88476ccja0889f"]
43      }
44    }
45  },
46  "result": {
47    "opportunityDetected": true,
48    "opportunityType": "plan_upgrade",
49    "recommendedOffer": "Premium Support Package",
50    "talkTrack": "Based on the technical issues you've mentioned, our Premium Support Package includes priority response times and a dedicated account manager who could help resolve these faster.",
51    "agentAttemptedUpsell": false,
52    "upsellOutcome": "not_attempted"
53  }
54}

Escalation Risk Detection

Monitors live conversations to detect signals that a customer interaction is at risk of escalation. This includes sudden negative sentiment shifts and explicit escalation cues such as requests for a supervisor, expressions of frustration, or threats to churn.

This operator uses a configurable sensitivity parameter to control how aggressively escalation signals are flagged.

API request

Escalation Risk Detection

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Escalation Risk Detection",
16    description:
17      "Detects escalation risk signals in real-time, including sentiment shifts and explicit escalation cues.",
18    prompt:
19      "Analyze this conversation for escalation risk. Look for: (1) sudden negative sentiment shifts, (2) explicit requests for supervisor or manager, (3) expressions of frustration or anger, (4) threats to cancel, churn, or take business elsewhere, (5) repeated unresolved complaints. Rate the escalation risk on a scale of 1-{{parameters.maxRiskLevel}} where {{parameters.maxRiskLevel}} is highest risk. Return the risk as a ratio (e.g., 8/10).",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        escalationRisk: {
25          type: "string",
26        },
27        riskLevel: {
28          type: "string",
29          enum: ["low", "medium", "high", "critical"],
30        },
31        triggerSignals: {
32          type: "array",
33          items: {
34            type: "string",
35          },
36        },
37        recommendedAction: {
38          type: "string",
39        },
40        verbatimCue: {
41          type: "string",
42        },
43      },
44    },
45    parameters: {
46      maxRiskLevel: {
47        type: "INTEGER",
48        default: 10,
49        required: false,
50        description: "Maximum value for the escalation risk scale.",
51      },
52    },
53  });
54
55  console.log(operator.id);
56}
57
58createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Escalation Risk Detection

1
2{
3  "escalationRisk": "8/10",
4  "riskLevel": "high",
5  "triggerSignals": [
6    "explicit_frustration",
7    "supervisor_request",
8    "churn_threat"
9  ],
10  "recommendedAction": "Acknowledge frustration, offer immediate resolution or warm transfer to supervisor.",
11  "verbatimCue": "This is ridiculous. I've been a customer for 5 years and I want to speak to your manager."
12}

Live Translation

Translates customer messages in real-time to a language spoken by the agent. Particularly useful for messaging channels where customers may communicate in their preferred language.

This operator uses a configurable target language parameter to specify the agent's language.

API request

Live Translation

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Live Translation",
16    description:
17      "Translates customer messages to the agent's preferred language in real-time.",
18    prompt:
19      "Translate the customer's most recent message to {{parameters.targetLanguage}}. Customer messages in the transcript are prefixed with CUSTOMER:. Preserve the original tone and intent. If the message is already in {{parameters.targetLanguage}}, return it unchanged. Also detect the source language.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        detectedLanguage: {
25          type: "string",
26        },
27        translatedMessage: {
28          type: "string",
29        },
30        translationNeeded: {
31          type: "boolean",
32        },
33        confidenceScore: {
34          type: "number",
35        },
36      },
37    },
38    parameters: {
39      targetLanguage: {
40        type: "STRING",
41        default: "English",
42        required: true,
43        description: "The language to translate customer messages into.",
44      },
45    },
46  });
47
48  console.log(operator.id);
49}
50
51createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Live Translation

1{
2  "detectedLanguage": "Spanish",
3  "translatedMessage": "I need help with my account. I was charged twice for my subscription last month and I want a refund.",
4  "translationNeeded": true,
5  "confidenceScore": 0.97
6}

Risk/Fraud Signal Detection

Flags language patterns associated with fraud, abuse, or suspicious behavior during live interactions. Detects social engineering attempts, account takeover signals, and policy abuse indicators.

This operator uses Conversation Memory to check account history for prior suspicious activity, and Enterprise Knowledge to reference known fraud patterns and red flags.

API request

Risk/Fraud Signal Detection

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Risk/Fraud Signal Detection",
16    description:
17      "Detects fraud, abuse, and suspicious behavior patterns in real-time conversations.",
18    prompt:
19      "Analyze this conversation for fraud and abuse signals. Look for: (1) social engineering attempts (urgency, authority claims, information fishing), (2) account takeover indicators (unable to verify identity, requesting credential changes), (3) policy abuse patterns (excessive refund requests, false claims), (4) suspicious inconsistencies in the customer's story. Flag any signals detected and assess overall risk level.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        fraudRiskDetected: {
25          type: "boolean",
26        },
27        riskLevel: {
28          type: "string",
29          enum: ["none", "low", "medium", "high", "critical"],
30        },
31        signalsDetected: {
32          type: "array",
33          items: {
34            type: "string",
35          },
36        },
37        signalCategory: {
38          type: "string",
39          enum: [
40            "social_engineering",
41            "account_takeover",
42            "policy_abuse",
43            "suspicious_behavior",
44            "none",
45          ],
46        },
47        evidence: {
48          type: "string",
49        },
50        recommendedAction: {
51          type: "string",
52        },
53      },
54    },
55    context: {
56      knowledge: {
57        enabled: true,
58      },
59    },
60  });
61
62  console.log(operator.id);
63}
64
65createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Response: Risk/Fraud Signal Detection

1{
2  "fraudRiskDetected": true,
3  "riskLevel": "high",
4  "signalsDetected": [
5    "urgency_pressure",
6    "identity_verification_avoidance",
7    "credential_change_request"
8  ],
9  "signalCategory": "account_takeover",
10  "evidence": "Caller claimed to be traveling and unable to access verification email, pressured agent to skip security questions, immediately requested password and email change.",
11  "recommendedAction": "Do not proceed with account changes. Escalate to fraud team for verification callback to number on file."
12}

Compliance/Disclosure Detection

Detects whether required disclosures, confirmations, or policy statements were delivered while the conversation is still happening. Enables real-time compliance monitoring and alerts agents to missing requirements before the conversation ends.

This operator uses Enterprise Knowledge to reference the specific compliance requirements, and a parameter to specify which policy document to check against.

API request

Compliance/Disclosure Detection

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Compliance/Disclosure Detection",
16    description:
17      "Monitors conversations for required disclosures and compliance statements in real-time.",
18    prompt:
19      "Review this conversation and check whether the agent has delivered the required disclosures and compliance statements defined in the policy document. For each requirement, indicate whether it was met, partially met, or missing. Flag any outstanding requirements that must still be addressed before the conversation ends.\n\nPolicy document:\n{{parameters.policyDocument}}",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        allRequirementsMet: {
25          type: "boolean",
26        },
27        requirementsChecked: {
28          type: "array",
29          items: {
30            type: "object",
31            properties: {
32              requirement: {
33                type: "string",
34              },
35              status: {
36                type: "string",
37                enum: ["met", "partially_met", "missing"],
38              },
39              verbatim: {
40                type: "string",
41              },
42            },
43          },
44        },
45        outstandingRequirements: {
46          type: "array",
47          items: {
48            type: "string",
49          },
50        },
51        complianceScore: {
52          type: "string",
53        },
54        urgentAlert: {
55          type: "boolean",
56        },
57      },
58    },
59    context: {
60      knowledge: {
61        enabled: true,
62      },
63    },
64    parameters: {
65      policyDocument: {
66        type: "KNOWLEDGE_BASE_AND_SOURCE_IDS",
67        required: true,
68        description:
69          "The compliance policy document to check requirements against.",
70      },
71    },
72  });
73
74  console.log(operator.id);
75}
76
77createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Compliance/Disclosure Detection

1{
2  "allRequirementsMet": false,
3  "requirementsChecked": [
4    {
5      "requirement": "Call recording disclosure",
6      "status": "met",
7      "verbatim": "This call may be recorded for quality assurance purposes."
8    },
9    {
10      "requirement": "Identity verification",
11      "status": "met",
12      "verbatim": "Can you please confirm your date of birth and the last four digits of your SSN?"
13    },
14    {
15      "requirement": "Fee disclosure",
16      "status": "missing",
17      "verbatim": ""
18    }
19  ],
20  "outstandingRequirements": [
21    "Fee disclosure: Agent must disclose the $25 processing fee before completing the transaction."
22  ],
23  "complianceScore": "2/3",
24  "urgentAlert": true
25}

Objection Handling

Identifies real-time objections as they arise in the conversation—such as concerns about price, timing, trust, or competition—and surfaces objection-handling guidance to help the agent respond effectively.

This operator uses Enterprise Knowledge to reference your objection-handling playbook and product information.

API request

Objection Handling

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Objection Handling",
16    description:
17      "Identifies customer objections in real-time and provides guidance for addressing them.",
18    prompt:
19      "Analyze this conversation for customer objections. Identify the type of objection (price, timing, trust, competition, authority, need, or other) and provide specific guidance on how the agent should respond. Reference relevant product information and proven objection-handling techniques.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        objectionDetected: {
25          type: "boolean",
26        },
27        objectionType: {
28          type: "string",
29          enum: [
30            "price",
31            "timing",
32            "trust",
33            "competition",
34            "authority",
35            "need",
36            "other",
37            "none",
38          ],
39        },
40        customerStatement: {
41          type: "string",
42        },
43        suggestedResponse: {
44          type: "string",
45        },
46        supportingPoints: {
47          type: "array",
48          items: {
49            type: "string",
50          },
51        },
52        toneGuidance: {
53          type: "string",
54        },
55      },
56    },
57    context: {
58      knowledge: {
59        enabled: true,
60      },
61    },
62  });
63
64  console.log(operator.id);
65}
66
67createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Objection Handling

1{
2  "objectionDetected": true,
3  "objectionType": "price",
4  "customerStatement": "That's more expensive than what we're currently paying with our existing provider.",
5  "suggestedResponse": "I understand budget is important. Many of our customers initially felt the same way, but found that our solution reduced their total cost of ownership by 30% within the first year through reduced maintenance and improved efficiency.",
6  "supportingPoints": [
7    "Highlight included features that competitors charge extra for",
8    "Mention the dedicated support included at no additional cost",
9    "Offer to provide a total cost of ownership comparison"
10  ],
11  "toneGuidance": "Acknowledge the concern without being defensive. Focus on value rather than defending the price."
12}

Conversation Scoring

Assigns a quality score to completed conversations based on agent performance criteria. Use for contact center QA, agent coaching, and performance tracking.

API request

Conversation Scoring

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Conversation Scoring",
16    description:
17      "Scores completed conversations based on agent performance and customer experience criteria.",
18    prompt:
19      "Evaluate this completed conversation and assign a score from 1-10 based on the following criteria:\n\n- Professionalism (25%): Was the agent friendly, clear, and professional throughout?\n- Problem Resolution (35%): Did the agent effectively resolve the customer’s issue?\n- Communication (20%): Did the agent communicate clearly and listen actively?\n- Efficiency (20%): Was the conversation handled efficiently without unnecessary delays?\n\nProvide an overall score, individual category scores, and specific feedback for coaching.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        overallScore: {
25          type: "string",
26        },
27        categoryScores: {
28          type: "object",
29          properties: {
30            professionalism: {
31              type: "string",
32            },
33            problemResolution: {
34              type: "string",
35            },
36            communication: {
37              type: "string",
38            },
39            efficiency: {
40              type: "string",
41            },
42          },
43        },
44        strengths: {
45          type: "array",
46          items: {
47            type: "string",
48          },
49        },
50        improvementAreas: {
51          type: "array",
52          items: {
53            type: "string",
54          },
55        },
56        coachingNotes: {
57          type: "string",
58        },
59      },
60    },
61  });
62
63  console.log(operator.id);
64}
65
66createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Conversation Scoring

1{
2  "overallScore": "8/10",
3  "categoryScores": {
4    "professionalism": "9/10",
5    "problemResolution": "8/10",
6    "communication": "8/10",
7    "efficiency": "7/10"
8  },
9  "strengths": [
10    "Maintained a friendly and empathetic tone throughout",
11    "Successfully resolved the billing dispute",
12    "Clearly explained the resolution and next steps"
13  ],
14  "improvementAreas": [
15    "Took longer than necessary to locate the customer's account",
16    "Could have proactively offered a goodwill credit earlier"
17  ],
18  "coachingNotes": "Strong customer rapport. Focus on improving familiarity with the billing system to reduce handle time."
19}

Lead Qualification

Analyzes completed sales conversations to qualify leads based on buying signals and readiness indicators. Use for sales pipeline prioritization and follow-up automation.

API request

Lead Qualification

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Lead Qualification",
16    description:
17      "Qualifies leads based on buying signals and readiness indicators from sales conversations.",
18    prompt:
19      "Analyze this sales conversation and qualify the lead. Identify buying signals such as pricing inquiries, timeline discussions, decision-maker involvement, and budget mentions. Classify the lead's likelihood to close and recommend appropriate follow-up actions.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        leadScore: {
25          type: "string",
26        },
27        leadCategory: {
28          type: "string",
29          enum: ["hot", "warm", "cold", "disqualified"],
30        },
31        buyingSignals: {
32          type: "array",
33          items: {
34            type: "string",
35          },
36        },
37        concerns: {
38          type: "array",
39          items: {
40            type: "string",
41          },
42        },
43        decisionMakerInvolved: {
44          type: "boolean",
45        },
46        estimatedTimeline: {
47          type: "string",
48        },
49        recommendedFollowUp: {
50          type: "string",
51        },
52        nextSteps: {
53          type: "array",
54          items: {
55            type: "string",
56          },
57        },
58      },
59    },
60  });
61
62  console.log(operator.id);
63}
64
65createOperator();

Sample result

Sample result: Lead Qualification

1{
2  "leadScore": "8/10",
3  "leadCategory": "hot",
4  "buyingSignals": [
5    "Asked about annual pricing discounts",
6    "Mentioned current contract ends next month",
7    "Requested a technical demo for their team"
8  ],
9  "concerns": [
10    "Needs approval from IT security team",
11    "Integration with existing CRM"
12  ],
13  "decisionMakerInvolved": true,
14  "estimatedTimeline": "30-45 days",
15  "recommendedFollowUp": "Schedule technical demo within 1 week, prepare security documentation",
16  "nextSteps": [
17    "Send security compliance documentation",
18    "Schedule demo with technical team",
19    "Prepare CRM integration case study"
20  ]
21}

Tailored Summaries

Generates structured conversation summaries in a custom format designed for your specific workflow. This example uses the BANT framework for sales conversations.

API request

Tailored Summaries

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Tailored Summaries",
16    description:
17      "Generates structured conversation summaries in a custom format designed for specific workflows.",
18    prompt:
19      "Summarize this sales conversation using the BANT framework:\n\n- Budget: Does the customer have a budget allocated? What is it?\n- Authority: Is this person the decision-maker? Who else is involved?\n- Need: What problem is the customer trying to solve?\n- Timeline: When does the customer need a solution in place?\n\nProvide clear, actionable insights for each category.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        budget: {
25          type: "object",
26          properties: {
27            identified: {
28              type: "boolean",
29            },
30            amount: {
31              type: "string",
32            },
33            notes: {
34              type: "string",
35            },
36          },
37        },
38        authority: {
39          type: "object",
40          properties: {
41            isDecisionMaker: {
42              type: "boolean",
43            },
44            role: {
45              type: "string",
46            },
47            otherStakeholders: {
48              type: "string",
49            },
50          },
51        },
52        need: {
53          type: "object",
54          properties: {
55            primaryProblem: {
56              type: "string",
57            },
58            painPoints: {
59              type: "array",
60              items: {
61                type: "string",
62              },
63            },
64            desiredOutcome: {
65              type: "string",
66            },
67          },
68        },
69        timeline: {
70          type: "object",
71          properties: {
72            urgency: {
73              type: "string",
74              enum: [
75                "immediate",
76                "short_term",
77                "medium_term",
78                "long_term",
79                "unknown",
80              ],
81            },
82            targetDate: {
83              type: "string",
84            },
85            drivingEvent: {
86              type: "string",
87            },
88          },
89        },
90        overallAssessment: {
91          type: "string",
92        },
93      },
94    },
95  });
96
97  console.log(operator.id);
98}
99
100createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Tailored Summaries

1{
2  "budget": {
3    "identified": true,
4    "amount": "$50,000-75,000 annually",
5    "notes": "Budget approved for this fiscal year, but needs to be spent by Q4"
6  },
7  "authority": {
8    "isDecisionMaker": false,
9    "role": "Director of Operations",
10    "otherStakeholders": "VP of Technology has final sign-off, Procurement involved for contracts over $50k"
11  },
12  "need": {
13    "primaryProblem": "Current system cannot handle increased call volume after expansion",
14    "painPoints": [
15      "Dropped calls during peak hours",
16      "No visibility into agent performance",
17      "Manual reporting taking 10+ hours per week"
18    ],
19    "desiredOutcome": "Scalable solution with real-time analytics and automated reporting"
20  },
21  "timeline": {
22    "urgency": "short_term",
23    "targetDate": "End of Q3",
24    "drivingEvent": "New product launch expected to double inbound call volume"
25  },
26  "overallAssessment": "Strong fit with clear need and budget. Focus on building relationship with VP of Technology and addressing scalability requirements in proposal."
27}

Follow-up Action Items

Extracts commitments, next steps, and follow-up tasks from completed conversations. Use to automate task creation and ensure nothing falls through the cracks.

API request

Follow-up Action Items

1// Download the helper library from https://www.twilio.com/docs/node/install
2const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
3
4// Find your Account SID at twilio.com/console
5// Provision API Keys at twilio.com/console/runtime/api-keys
6// and set the environment variables. See http://twil.io/secure
7// For local testing, you can use your Account SID and Auth token
8const accountSid = process.env.TWILIO_ACCOUNT_SID;
9const apiKey = process.env.TWILIO_API_KEY;
10const apiSecret = process.env.TWILIO_API_SECRET;
11const client = twilio(apiKey, apiSecret, { accountSid: accountSid });
12
13async function createOperator() {
14  const operator = await client.intelligence.v3.operators.create({
15    displayName: "Follow-up Action Items",
16    description:
17      "Extracts action items, commitments, and follow-up tasks from completed conversations.",
18    prompt:
19      "Review this conversation and extract all action items, commitments, and follow-up tasks. For each item, identify who is responsible (agent or customer), what needs to be done, and any mentioned deadlines or timeframes. Prioritize items by urgency.",
20    outputFormat: "JSON",
21    outputSchema: {
22      type: "object",
23      properties: {
24        actionItems: {
25          type: "array",
26          items: {
27            type: "object",
28            properties: {
29              task: {
30                type: "string",
31              },
32              owner: {
33                type: "string",
34                enum: ["agent", "customer", "other"],
35              },
36              deadline: {
37                type: "string",
38              },
39              priority: {
40                type: "string",
41                enum: ["high", "medium", "low"],
42              },
43              context: {
44                type: "string",
45              },
46            },
47          },
48        },
49        agentCommitments: {
50          type: "array",
51          items: {
52            type: "string",
53          },
54        },
55        customerCommitments: {
56          type: "array",
57          items: {
58            type: "string",
59          },
60        },
61        followUpRequired: {
62          type: "boolean",
63        },
64        suggestedFollowUpDate: {
65          type: "string",
66        },
67      },
68    },
69  });
70
71  console.log(operator.id);
72}
73
74createOperator();

Sample result

The following response example shows the result property of the OperatorResult. To view the full response structure, see the Upsell Opportunity Detection example.

Sample result: Follow-up Action Items

1{
2  "actionItems": [
3    {
4      "task": "Send updated contract with revised pricing",
5      "owner": "agent",
6      "deadline": "End of day today",
7      "priority": "high",
8      "context": "Customer requested 15% volume discount reflected in writing"
9    },
10    {
11      "task": "Schedule technical demo with IT team",
12      "owner": "agent",
13      "deadline": "This week",
14      "priority": "high",
15      "context": "Customer wants to include their CTO and two engineers"
16    },
17    {
18      "task": "Provide list of current integrations",
19      "owner": "customer",
20      "deadline": "Before demo",
21      "priority": "medium",
22      "context": "Needed to prepare customized demo environment"
23    }
24  ],
25  "agentCommitments": [
26    "Send revised contract by end of day",
27    "Schedule demo for this week",
28    "Include case study from similar-sized company"
29  ],
30  "customerCommitments": [
31    "Send list of current integrations",
32    "Confirm demo attendees by Wednesday"
33  ],
34  "followUpRequired": true,
35  "suggestedFollowUpDate": "3 days from now if contract not signed"
36}

Next steps

After creating a custom language operator:

Add the operator to an intelligence configuration rule to start analyzing conversations
Review the Rule Execution webhook payload to understand the OperatorResult data you'll receive when consuming Rule Executions.