Skip to main content
Welcome to the PolyAI glossary. This page explains some of the key terms, acronyms, and concepts used across our platform.

​
A–C

​
A2P 10DLC

Application-to-Person 10-Digit Long Code. A regulatory framework in the US requiring registration for businesses sending SMS messages. Required for all US-based Twilio numbers to prevent message blocking.

​
Agent

A PolyAI AI-driven voice assistant that interacts with customers in real-time across multiple channels including voice (telephony), chat (webchat), and SMS. Agents handle customer conversations autonomously while integrating with external data sources and APIs. See also: Agent settings, Quickstart guide

​
Agent Studio

The primary interface for designing, configuring, and deploying AI agents. Agent Studio serves both builders (creating AI logic) and managers (monitoring performance and analytics). See also: Getting started, Build essentials

​
Annotation

Full article: Conversation review A manual tag applied during Conversation Review to highlight issues like incorrect transcriptions or missing Managed Topics.

​
ASR (Automatic Speech Recognition)

The technology that converts spoken language into written text. PolyAI uses advanced ASR models optimized for conversational accuracy with support for multiple languages, accents, and industry-specific vocabulary. See also: ASR biasing, Speech recognition

​
ASR biasing

Full article: ASR biasing A technique to improve speech recognition accuracy by instructing the ASR model to prioritize specific words or phrases. Increases the likelihood of correctly transcribing domain-specific terms, names, or critical vocabulary.

​
Barge-in

When a user interrupts the agent mid-sentence. The system detects this and stops playback to process the user’s input immediately, creating more natural conversation flow.

​
BYOM (Bring Your Own Model)

Full article: BYOM A feature allowing customers to integrate their own Large Language Model by exposing an API endpoint that follows the OpenAI chat/completions schema.

​
Channel

The medium through which users interact with the agent. Supported channels include VOICE-SIP (telephony), CHAT (webchat), and SMS. See also: Telephony, Webchat, SMS

​
Chunking

The process of splitting large bodies of text into smaller pieces (‘chunks’). When you connect knowledge from outside of Agent Studio (e.g., via websites, documents or application such as Zendesk), we scrape the text from those sources. This text is too large to feed directly to LLM, so it is split into ‘chunks’. These chunks can change in size and generally have some level of overlap of content with other chunks. It is these specific chunks that can be retrieved by RAG based on user input and given to the LLM. See also: Connected knowledge, RAG

​
Connected knowledge

Full article: Connected knowledge Knowledge that exists outside of Agent Studio that can be connected to your agent. We support three types of knowledge connections:
  • Documents (e.g., PDFs)
  • Applications (e.g., Zendesk)
  • Websites
See also: Chunking, RAG

​
Containment rate

The percentage of conversations fully handled by the agent without requiring a human handoff. A key performance metric for measuring agent effectiveness across all channels. See also: Call handoff, Performance monitoring, Standard dashboards

​
Conversation metadata

Structured data about a conversation, including duration, start time, and associated agent variant. See also: Conversations API, Call data

​
Conversation diagnosis

Full article: Conversation diagnosis A tool within Conversation Review that shows which flows, function calls, and Managed Topics were activated during a conversation. Helps troubleshoot and understand agent behavior across voice, webchat, and SMS interactions. See also: Conversation review, Annotations

​
D–F

​
Dialogue context

A globally-accessible object containing all information needed for the agent to process a conversation, including turn history, state variables, node loader, and services. See also: Conv object, Variables

​
Draft

The state between the latest published version and ongoing changes. Drafts become versions upon publishing and can be deleted to revert to the most recent published version. See also: Environments and versions, Version management

​
DTMF (Dual-Tone Multi-Frequency)

Full article: DTMF Touch-tone input from phone keypads. Allows users to provide input by pressing number keys instead of speaking, useful for entering PINs, account numbers, or menu selections.

​
Embedding

A numerical vector representation of text used for semantic search and retrieval. The Ragdoll service computes embeddings for Knowledge Base topics to enable RAG-based matching. See also: RAG, Managed Topics

​
End function

Full article: End function A function that finalizes an interaction, used when an AI agent has completed its task. It can:
  • Close conversations and send confirmation messages.
  • Trigger logging or analytics tracking.
  • Perform clean-up actions before ending the session.

​
Entity

Typed extracted data from user input, such as phone numbers, dates, names, or addresses. Entities help structure and validate information collected during conversations. See also: Flows, Variables

​
Event-sourced

A data architecture pattern where all changes are stored as a sequence of events. The Conversations API v3 uses event-sourcing for reliable, scalable data ingestion and querying. See also: Conversations API v3, Call data

​
Flows

Full article: Flows Flows use conversation logic system that determines how an AI agent guides a user through an interaction. Flows consist of sequential steps, each containing text prompts and optional functions. Flows define:
  • Decision points (when the AI needs user input)
  • Branching logic (how responses change based on user choices)
  • Automated actions (like triggering a function call)
  • Transition functions (custom logic to move between steps)
See also: Triggering flows, Transition functions, Flow examples

​
Function

Full article: Function A reusable backend operation that an AI agent can execute during a conversation. Functions can be global (available throughout the agent) or flow-specific (transition functions). Functions allow agents to:
  • Retrieve external data (like fetching an order status).
  • Modify system state (like updating a customer’s profile).
  • Perform calculations or conditional logic.
  • Use conv.log for structured logging.
A function call is when an agent invokes a function to retrieve information, or perform an action in real time. See also: How to setup functions, Function classes, Start function, End function

​
G–L

​
IPA (International Phonetic Alphabet)

A standardized system for representing pronunciation. Used in the Pronunciations feature to define how the agent should pronounce specific terms or phrases. See also: Voice configuration, Voice audio updates

​
Keyphrase boosting

Full article: Keyphrase boosting A feature that biases the ASR model toward recognizing specific words and phrases, improving transcription accuracy for domain-specific terminology. See also: ASR biasing, Speech recognition

​
Global rules

Full article: Rules Predefined behavior constraints applied across all agent interactions to ensure:
  • Consistency in responses
  • Compliance with business policies
  • Controlled conversational tone
Global rules are enforced by the LLM during response generation. See also: Agent settings, Response control

​
Handoff

Full article: Call handoff The process of transferring a user from an AI agent to a human agent. Handoffs can be:
  • Rule-based (triggered by predefined conditions)
  • User-requested (when a customer asks for a human)
  • AI-driven (when the agent determines it cannot complete the task)

​
LLM (Large Language Model)

The AI model that powers the agent’s understanding and response generation. Examples include GPT-4, Claude, and PolyAI’s proprietary Raven model. See also: Model use, BYOM

​
Live

The production environment where the agent handles real customer traffic. Also referred to as the production environment. See also: Environments and versions, Version management

​
Managed Topics

Full article: Managed Topics A structured repository of predefined responses and business-specific information that AI agents use to generate accurate answers. Topics can trigger actions like function calls, handoffs, or sending SMS messages. See also: RAG, Actions, Knowledge base maintenance

​
Environment

Refers to the deployment stage of a project, such as sandbox, pre-release, or live. Used in API queries and analytics. See also: Environments and versions, Version management

​
M–P

​
NLU (Natural Language Understanding)

The component responsible for interpreting user input, detecting intents, and extracting entities. The StandardNLU class handles intent classification and value extraction. See also: Flows, Variables

​
Node

The basic unit of the policy state machine. Nodes define where the agent is in a conversation and how it should act, with three main functions: say(), listen(), and transition(). See also: Flows, No-code flows

​
Out-of-domain (OOD)

User input that falls outside the agent’s configured knowledge and capabilities. OOD turns are tracked in analytics and may trigger fallback behaviors. See also: Conversation review, Performance monitoring

​
Multi-site configuration

The ability to customize agent responses based on location, using variant management. See also: Variant management, CSV imports

​
Policy engine

The decision-making component that controls conversation flow by executing nodes in priority order: global nodes, current node, then fallback nodes. See also: Flows, Agent settings

​
Pre-release

A staging environment for user acceptance testing (UAT) before promoting to production. Allows final validation of changes before they reach live traffic. See also: Environments and versions, Version management

​
Processing

​
Project

A complete agent configuration including all knowledge, flows, functions, settings, and voice configuration. Projects can have multiple variants for A/B testing or multi-site deployments. See also: Variant management, Getting started

​
Pronunciations

Custom rules used to adjust how the agent pronounces specific terms with IPA and regex-based substitution. See also: Voice configuration, Voice audio updates

​
Performance metrics

Key indicators for measuring agent effectiveness and quality. See also: Performance monitoring, Standard dashboards, Safety dashboard

​
Ragdoll

The service responsible for computing and managing embeddings for Knowledge Base topics. Provides vector operations and runtime matching of topic embeddings against user input. See also: RAG, Managed Topics

​
Raven

PolyAI’s proprietary model, optimized for real-time voice interactions. Offers low-latency responses with high alignment to voice assistant use cases. See also: Model use, Agent settings

​
Q–Z

​
RAG (Retrieval-Augmented Generation)

Full article: RAG A method where the AI first retrieves relevant knowledge from the KB before generating a response, ensuring more accurate, context-aware replies. See also: Managed Topics, Connected knowledge

​
Response control

Full article: Response control A system that modifies how AI agents respond in different scenarios. Includes:
  • Rate-limiting (preventing excessive responses)
  • Interruption handling (allowing users to cut off the AI mid-sentence)
  • Compliance filtering (ensuring safe and appropriate responses)
See also: Agent settings, Rules

​
Safety dashboard

A specialized dashboard to monitor flagged content, risky user utterances, and the performance of safety filters. See also: Safety dashboard, Performance monitoring

​
Sandbox

The development environment where builders create, modify, and test agent versions before promoting to pre-release or live. See also: Environments and versions, Version management

​
SBC (Session Border Controller)

A network element that manages and secures SIP calls. SBCs handle call routing, security, and interoperability between different VoIP networks. See also: Telephony, Voice integrations

​
Secrets

Full article: Secrets Sensitive credentials or tokens that can be securely stored and accessed by the agent for integrations. Secrets can be used in functions and Knowledge Base topics with proper access control. See also: How to setup secrets, Access control, Functions

​
SIP (Session Initiation Protocol)

A signaling protocol used for initiating, maintaining, and terminating voice and video calls over IP networks. Common SIP methods include INVITE, REFER, and BYE. See also: Telephony, Voice integrations, Call handoff

​
SIP header

Metadata fields in SIP messages used to pass routing instructions or custom information during call setup and handoff. Custom headers typically start with X- prefix. See also: Call handoff, Telephony

​
SSML (Speech Synthesis Markup Language)

An XML-based markup language for controlling text-to-speech output. Supports tags like <break>, <prosody>, and <emphasis> to adjust pauses, pitch, and emphasis. See also: Voice configuration, Voice audio updates

​
Step

A self-contained conversation state within a flow, consisting of text prompts and optional functions. Steps are processed sequentially to guide structured interactions. See also: Flows, Flow examples, No-code flows

​
Stop keyword

Full article: Stop keywords A regular expression pattern used to halt or log agent responses containing specific phrases. Ensures safety compliance and brand adherence by preventing inappropriate outputs. See also: Response control, Rules

​
Start function

Full article: Start function A function triggered at the beginning of an interaction, often used to:
  • Initialize conversation state (e.g., retrieve user history).
  • Perform authentication or setup tasks.
  • Trigger conditional logic based on user input.

​
Transcript correction

Full article: Speech recognition A feature that enables users to edit AI-generated conversation transcripts, improving:
  • Speech recognition accuracy
  • Compliance with business policies
  • Training data quality

​
TTS (Text-to-Speech)

The technology that converts written text into spoken language. PolyAI supports multiple TTS providers and custom voice configurations. See also: Voice configuration, Choosing a good voice, Add a new voice

​
Turn

A single exchange in a conversation, defined as the execution between two consecutive user inputs. Contains user input, agent response, detected intents, extracted entities, and metadata. See also: Conversation review, Conversations API

​
UAT (User Acceptance Testing)

Testing performed in the pre-release environment to validate agent behavior before promoting to production. See also: Environments and versions, Version management

​
Utterance

An atomic unit of meaning independent of its surface form. For example, the utterance GREETING can have surface forms like “Hello”, “Hi”, or “Bonjour”. Defined in YAML files for multi-language support. See also: Multilingual agents, Multi-language updates

​
Validation

Full article: Flows A moment in the conversation where the agent checks whether the information provided by the user is complete, accurate, or matches expected criteria. Validation may include:
  • Repeating back a value to confirm correctness (e.g. “That’s 07888 888888 — is that right?”)
  • Comparing user input against a list (e.g. matching a name to a reservation)
  • Prompting again if the input is unclear, incomplete, or invalid
Validation ensures the agent gathers usable information before continuing with a task or triggering a function.

​
Variable

Full article: Variables Variables are used to store and retrieve values during a conversation. In PolyAI, they are accessed through the conv.state object, which behaves like a dictionary. Variables allow agents to track context, user inputs, flags, counters, and other custom values needed for decision-making across turns. Example: 
conv.state.user_name = "Aaron"
if conv.state.has_account:
    conv.goto_flow("account_support")
All variables persist for the duration of a single conversation and are cleared at the end unless explicitly saved elsewhere.

​
Value extractor

An extractive model that identifies and extracts specific information (entities) from user input, such as dates, times, names, or phone numbers. See also: Entity, NLU

​
Variant

Full article: Variant management A tool for testing multiple conversational styles within an AI agent. Variants can have different configurations, not just conversational styles, and support multi-site deployments. Allows:
  • A/B testing across different dialogue configurations
  • Controlled rollouts of conversation updates
  • Customization per brand, region, or customer type
See also: Project, Multi-site configuration

​
Variant ID

Fields used in API filters and analytics to identify and segment conversations by specific agent variant versions.

​
VoIP (Voice over Internet Protocol)

Technology for delivering voice communications over IP networks rather than traditional telephone lines. See also: SIP, SBC