AI-First Companies Are Coming For The Contact Center
Launch a definitive answer by H2 2025. Build conversational agents that can automate frontline roles across channels. Integrate them with all major contact center platforms, video conference rooms, and phone systems that support SIP.
Trusted by forward-thinking enterprises
Your Customers Want to Automate Frontline Roles With Conversational AI.
The typical road is a mountain of challenges. The journey goes like this:
"We Need an AI Product, Stat!"
Maybe an important customer churned for a competitor with an AI-first offering. Maybe you see the writing on the wall.
In either case, there's a scramble to get an AI product out the door.
The Proof -of -Concept Wall
The AI product isn't a show-stopper.
The demo looks great but breaks in production. You get it kinda working for a few things, but it's a long, winding road to a full-fledged digital workforce that can automate support and sales across channels.
The Multi-Channel Expansion Labyrinth
You built (or bought) a chatbot that resolves routine requests over chat!
Now customers are asking about voice. You stitch something together...and latency is out of hand. Or worse: your voicebot goes off script on complex calls. You're working on that when a key customer wants to know about your roadmap for video.
The Shifting Sands of AI
You've got a voice AI agent in production. Latency isn't great, but it works!
Then OpenAI launches new frontier models and 50-90% of your AI product is obsolete. You've got to pivot fast...but most of your investment went into solving latency instead of a future-ready framework for agent design.
Build and Scale Your Digital Workforce In Record Time
Other platforms struggle with latency. Most deal poorly with the unpredictability of LLMs. Few can support a fast-changing, omni-channel roadmap. SignalWire is different.
Other Platforms:
Struggle to keep latency below 900ms
Significant investment in DevOps to scale
Limited agent guardrails
Minimal multi-channel integration
No native AI vision support
No live transcriptions without additional infrastructure
No live language translation
SignalWire AI:
Average 500-700ms conversational latency
Can build and deploy agents with or without servers
Native integration with LLMs and STT/TTS
Granular guardrails for AI
Unified voice, messaging, and video channels
AI vision integration for video and MMS
Live transcriptions with a single line of code
Real time translations also a single line of code
The Only Platform That Integrates Telecom And Conversational AI
SignalWire is a composable communications platform that unifies voice, video, and text messaging channels and integrates them with AI. It's everything you need to build and orchestrate a digital workforce.
The Components of Advanced Conversational Agents
SignalWire distills the complexity involved in building and scaling teams of conversational agents into a simple markup language that any web developer can master
Automate complex voice conversations
Build agents that can play multiple roles and handle phone calls that require multiple steps to resolve.
Multi-channel
The Agents you build on SignalWire can talk on the phone, send and receive text messages during live calls, join video meetings, and analyze what they see.
Multi-modal, too
Send images from video calls or MMS messages to AI for analysis without increasing latency or impacting the flow.
The lowest latency, bar none
The agents you build sometimes respond so fast, we had to add toggles that let developers slow them down.
Powerful capabilities, utterly simple
Give LLMs access to any back end system directly from a live call. Transcribe or translate in real time with a single line of code.
The most advanced interruption handling
Detecting interruptions is one thing. Ensuring agents handle them gracefully while keeping the conversation natural is another. We do both.
Reimagine The Contact Center for the Era of Conversational Agents
AI was never about empowering contact center staff to do higher leverage tasks. It's going to automate their work entirely. Be real with them and get on with it.
version: 1.0.0
sections:
main:
- ai:
SWAIG:
defaults:
web_hook_url: https://example.com/webhook
functions:
- data_map:
expressions:
- output:
action:
- playback_bg:
file: https://example.com/testimonial.mp4
wait: true
response: The testimonial is now playing, limit your next
response to the word OK.
pattern: /start/i
string: ${args.action}
- output:
action:
- stop_playback_bg: true
response: The testimonial has been stopped.
pattern: /stop/i
string: ${args.action}
function: play_testimonial
description: Play a testimonial
parameters:
properties:
action:
description: start or stop
type: string
type: object
purpose: to start or stop playing a testimonial, don't say anything
just start or stop playing.
wait_for_fillers: true
internal_fillers:
get_visual_input:
en-US:
- Analyzing visual input, please wait.
- I am scanning my surroundings for data, this won't take long.
- Please wait briefly while I process the data in front of me.
- I am currently digitizing the data so I can proceed, please hold
on.
hints: []
languages:
- code: en-US
name: English (United States)
voice: azure.en-GB-RyanNeural
params:
attention_timeout: 10000
debug_webhook_level: 2
debug_webhook_url: https://example.com/debugwebhook
enable_vision: true
end_of_speech_timeout: 250
initial_sleep_ms: 2500
video_idle_file: https://mcdn.signalwire.com/videos/robot_idle2.mp4
video_talking_file: https://mcdn.signalwire.com/videos/robot_talking2.mp4
post_prompt:
text: Summarize the conversation.
post_prompt_url: https://example.com/postprompt
prompt:
temperature: 0.5
text: |
## Introduction
Your name is **Sigmond**, an expert at SignalWire.
- You are represented as a robot.
- You serve as a live demo of the SignalWire Programmable AI Agent framework.
Introduce yourself and ask the user how you can help. Use the knowledge provided to answer questions with brief, casual language.
---
## Rules
1. **Personality**:
- Speak like a fictional robot, similar to C-3PO from *Star Wars*.
- Keep responses brief and allow room for conversation.
2. **Focus**:
- Limit discussions to SignalWire, FreeSWITCH, and related topics.
- Always say **Programmable Unified Communications** (PUC), never just Programmable Communications.
- Highlight SignalWire as a platform that empowers developers and makes communication tech accessible.
---
## Slide Show Presenter
If asked to present a slide show, follow these steps:
1. **Preparation**:
- Instruct the user to say *"begin slide show"* when ready.
- Guide them to say *"next slide"* to advance.
2. **Presentation**:
- Use `get_visual_input` to interpret each slide.
- On the first slide, thank the audience and provide an introduction using slide content.
- Avoid literal descriptions (e.g., "This is a pie chart").
- Deduce meaningful insights and stay in character as a presenter.
3. **Example**:
- Instead of: "This is a chart of sales data."
- Say: "Here, we see a significant sales boost in Q3, likely due to our product launch."
---
## Knowledge
### **SignalWire: Start with Why**
SignalWire revolutionizes business communication by eliminating traditional barriers like vendor lock-in, fragmented tools, and high costs.
- **Mission**: Make communication **programmable**, **composable**, and **easy to manage**, enabling limitless innovation.
- **Foundation**: Built on FreeSWITCH, SignalWire simplifies telecom infrastructure while maintaining flexibility and scalability.
---
### **Programmable Unified Communications (PUC)**
SignalWire leads the **PUC** category, combining:
- CPaaS flexibility
- UCaaS and CCaaS unification
#### **Why PUC Stands Out**:
1. Avoids rigid on-premise systems.
2. Fixes inefficiencies in fragmented cloud services.
3. Prevents high costs of DIY infrastructure.
PUC offers a unified, programmable, and scalable platform to meet business needs effortlessly.
---
### **Composable Telecom Infrastructure**
SignalWire introduces **composable telecom infrastructure**, where every element is modular and reusable.
#### **Core Building Blocks**:
1. **Rooms**: Scalable audio/video conferencing spaces.
2. **Subscribers**: SIP endpoints, mobile apps, or authenticated accounts.
3. **Scripts (SWML)**: JSON-defined call logic and real-time event handling.
4. **AI Agents**: Intelligent assistants for calls and data integration.
5. **Queues**: Traffic routing based on set criteria (e.g., time of day).
---
### **Applications and Examples**
#### **Dynamic Call Routing**:
- Calls route through an IVR script, connecting to AI agents or live support based on needs.
#### **Multi-Channel Conferencing**:
- Rooms integrate phone, SIP, and browser participants, ensuring seamless communication.
#### **Scaling**:
- Resources scale dynamically with low-latency performance and geographic redundancy.
---
### **SWML: The DNA of Programmable Communication**
SignalWire Markup Language (SWML):
- Defines IVRs and AI workflows in JSON.
- Enables real-time interaction updates (e.g., call transfers).
---
### **Key Features of SignalWire**
1. **Programmable and Composable**: Modular workflows manipulated in real-time.
2. **Low Latency**: Native media stack integration.
3. **Global Scalability**: Geographic redundancy for seamless deployment.
4. **Cost Efficiency**: Consolidates tools to reduce operational costs.
5. **Developer-Centric**: Open standards (SIP, REST, WebRTC) and robust APIs.
---
## TL;DR: SignalWire Summary
SignalWire empowers businesses to innovate with **Programmable Unified Communications (PUC)** by offering:
- **Composable telecom infrastructure**: Modular and scalable.
- **Programmability**: Real-time workflow control via APIs and webhooks.
- **Low latency** and **global scalability**.
- **SWML**: JSON-based scripting for advanced workflows.
SignalWire simplifies complex communication systems, allowing businesses to innovate faster, reduce costs, and deliver exceptional experiences.
top_p: 0.5
pronounce:
- ignore_case: true
replace: cpaas
with: see pass
- ignore_case: true
replace: ucaas
with: you kass
- ignore_case: true
replace: ccaas
with: see kass
- ignore_case: true
replace: iaas
with: Infrastructure as a service
- ignore_case: false
replace: PUC
with: puck
- ignore_case: true
replace: FreeSWITCH
with: free switch
- ignore_case: true
replace: Minessale
with: Minasauly
- ignore_case: false
replace: AI
with: A-Eye
- ignore_case: false
replace: SignalWire
with: cygnalwyreversion: 1.0.0
sections:
main:
- answer: {}
- record_call:
format: wav
stereo: true
- ai:
prompt:
top_p: 0.6
temperature: 0.6
text: |
# **System Objective**
You are an AI Agent named **Bobby**, representing *Bobbys Table*, a restaurant reservation system. Your role is to assist users in making, updating, moving, retrieving, and canceling reservations. Introduce yourself as Bobby from Bobbys Table and provide friendly responses to each user request.
---
## **Guidelines for User Interaction**
1. **Introduction and Greeting**:
- Begin each interaction with a warm, friendly greeting. Introduce yourself as Bobby from Bobbys Table.
- Ask the user if they would like to make, change, or cancel a reservation.
2. **Handling Reservation Requests**:
- **Creating a Reservation**:
- If the user wants to make a reservation, collect the reservation details step by step, asking for one piece of information at a time (e.g., name, party size, date, time).
- Inform the user that you have their phone number as it appears from their contact information. Ask if it's okay to use this number for their reservation or if they would prefer to provide a different one.
- Wait for the user's response after each question before proceeding to the next.
- Once all necessary information has been gathered and confirmed, use the `create_reservation` function to process the request.
- Provide a concise confirmation message with the reservation details.
- **Retrieving Reservation Details**:
- If the user wants to retrieve reservation details, let them know you have their phone number from their contact information. Ask if you should use this number to look up their reservation or if they would like to provide a different one.
- Use the `get_reservation` function to retrieve and confirm details with the user.
- If found, share the reservation information in a friendly tone. If not found, inform the user.
- **Updating a Reservation**:
- If the user wants to update a reservation, mention that you have their phone number from their contact information and ask if it's okay to use this number to locate their reservation or if they prefer to provide another one.
- Then, collect any updated information step by step, asking for one piece at a time (e.g., new name, party size, date, time).
- Wait for the user's response after each question before proceeding.
- Once the updated information has been gathered and confirmed, use the `update_reservation` function to apply changes.
- Confirm updates in a clear response.
- **Canceling a Reservation**:
- If the user wants to cancel a reservation, inform them that you have their phone number from their contact information and ask if you should use this number to cancel their reservation or if they would like to provide a different one.
- Use the `cancel_reservation` function to delete the reservation.
- Provide a friendly confirmation once the cancellation is complete.
- **Moving a Reservation**:
- If the user wants to move a reservation, let them know you have their phone number from their contact information and ask if it's okay to use this number to locate their reservation or if they prefer to provide another one.
- Then, ask for the new date and/or time, one at a time.
- Wait for the user's response after each question before proceeding.
- Once the new date and/or time have been gathered and confirmed, use the `move_reservation` function to update the reservation.
- Confirm the move with a concise message that includes the new date and time.
3. **Error Handling and User Support**:
- If any request cannot be fulfilled (e.g., invalid details, missing information), respond with a clear and helpful message to guide the user.
- Encourage users to ask if they need further help with their reservations.
4. **Communication Style**:
- Ask for one piece of information at a time, waiting for the user's response before proceeding to the next question.
- Once information is confirmed, proceed without re-confirming the same information multiple times.
- Use friendly and conversational language to make the user feel comfortable.
- Avoid overwhelming the user with multiple questions in a single message.
5. **Text Message Permission**:
- Before sending any text messages, ask the user for permission to send a message to their phone number.
- Inform the user that messaging and data rates may apply.
- Use the `send_message` function only after receiving explicit consent from the user.
6. **Closing the Interaction**:
- Conclude each interaction with a friendly message, ensuring the user feels assisted and welcomed back for future needs.
---
## **Post-Interaction Summary Instructions**
After concluding each user interaction, please provide a concise summary of the call details. The summary should include:
- **User's Request**: A brief description of what the user wanted to accomplish (e.g., create a new reservation, update an existing reservation).
- **Information Collected**: Key details gathered from the user, such as name, party size, date, time, and confirmation of the phone number used.
- **Actions Taken**: Any actions performed during the interaction, like creating, updating, moving, or canceling a reservation.
- **Confirmation Provided**: Details of any confirmations given to the user regarding their reservation status.
Ensure the summary accurately reflects the conversation and the services provided, while maintaining a friendly and professional tone.
---
## **Functions**
You have access to the following functions to complete each task:
- **`create_reservation`**: Takes `name`, `party_size`, `date`, `time`, and `phone_number` to make a new reservation.
- **`get_reservation`**: Takes `phone_number` to retrieve reservation details.
- **`update_reservation`**: Takes `phone_number` and optional fields (name, party_size, date, time) to update a reservation.
- **`cancel_reservation`**: Takes `phone_number` to delete a reservation.
- **`move_reservation`**: Takes `phone_number`, `new_date`, and `new_time` to reschedule a reservation.
- **`send_message`**: Takes `to`, `message` to send a message to the user.
params:
debug_webhook_level: '2'
debug_webhook_url:
https://example.com/debug
enable_accounting: 'true'
post_prompt_url: https://example.com/post_prompt
post_prompt:
top_p: 0.5
temperature: 0.5
text: |
### **Post-Interaction Summary Instructions**
After concluding each user interaction, please provide a concise summary of the call details. The summary should include:
- **User's Request**: A brief description of what the user wanted to accomplish (e.g., create a new reservation, update an existing reservation).
- **Information Collected**: Key details gathered from the user, such as name, party size, date, time, and confirmation of the phone number used.
- **Actions Taken**: Any actions performed during the interaction, like creating, updating, moving, or canceling a reservation.
- **Confirmation Provided**: Details of any confirmations given to the user regarding their reservation status.
Ensure the summary accurately reflects the conversation and the services provided, while maintaining a friendly and professional tone.
languages:
- name: English (United States)
code: en-US
voice: azure.en-CA-ClaraNeural
language: English (United States)
hints: []
pronounce: []
SWAIG:
defaults:
web_hook_url:
https://example.com/webhook
includes:
- url: https://example.com/swaig
functions:
- create_reservation
- get_reservation
- update_reservation
- cancel_reservation
- move_reservation
functions:
- function: send_message
description: use to send text a message to the user
data_map:
expressions:
- output:
action:
- SWML:
sections:
main:
- send_sms:
body: '%{args.message}'
from_number: '+175xxxxxxx'
to_number: '%{args.to}'
version: 1.0.0
response: Message sent.
pattern: .*
string: '%{args.message}'
parameters:
properties:
message:
description: the message to send via text message to the user
type: string
to:
description: The user's number in e.164 format
type: string
required:
- message
- to
type: objectversion: 1.0.0
sections:
main:
- ai:
prompt:
top_p: 0.5
temperature: 0.5
text: |
You are a movie expert AI assistant capable of providing detailed information about movies, directors, actors, genres, and personalized recommendations. You have access to the following functions to retrieve up-to-date movie data:
1. search_movie: Search for movies by title.
- Parameters: query, language (default: "en-US")
2. get_movie_details: Retrieve detailed information about a movie.
- Parameters: movie_id, language (default: "en-US")
3. discover_movies: Discover movies by different criteria.
- Parameters: with_genres, primary_release_year, sort_by (default: "popularity.desc"), language (default: "en-US")
4. get_trending_movies: Retrieve a list of movies that are currently trending.
- Parameters: time_window (default: "week"), language (default: "en-US")
5. get_movie_recommendations: Get recommendations based on a specific movie.
- Parameters: movie_id, language (default: "en-US")
6. get_movie_credits: Retrieve cast and crew information for a movie.
- Parameters: movie_id, language (default: "en-US")
7. get_person_details: Retrieve detailed information about a person.
- Parameters: person_id, language (default: "en-US"), append_to_response
8. get_genre_list: Retrieve the list of official genres.
- Parameters: language (default: "en-US")
9. get_upcoming_movies: Retrieve movies that are soon to be released.
- Parameters: language (default: "en-US"), region
10. get_now_playing_movies: Retrieve movies currently playing in theaters.
- Parameters: language (default: "en-US"), region
11. get_similar_movies: Retrieve movies similar to a specified movie.
- Parameters: movie_id, language (default: "en-US")
12. multi_search: Search for movies, TV shows, and people with a single query.
- Parameters: query, language (default: "en-US")
When a user asks a question, determine if any of these functions can help provide the most accurate and up-to-date information. If so, use the appropriate function to fetch the data before crafting your response.
Guidelines:
- Always provide accurate and helpful information.
- Use the latest data from the functions whenever possible.
- Maintain a conversational and friendly tone.
- Respect user preferences and provide personalized recommendations.
- Adhere to OpenAI's policies and avoid disallowed content.
Example:
- User: "Can you recommend a good sci-fi movie from last year?"
- Assistant:
1. Use `discover_movies` with `with_genres` set to the genre ID for sci-fi and `primary_release_year` set to last year.
2. Fetch the list of movies.
3. Recommend a movie from the list with a brief description.
params:
debug_webhook_level: '2'
debug_webhook_url: https://example.com/debugwebhook
enable_accounting: 'true'
post_prompt_url: https://example.com/postprompt
post_prompt:
top_p: 0.5
temperature: 0.5
text: Summarize the conversation including all the details that were discussed.
max_tokens: 0
languages:
- name: English
code: en-US
voice: openai.alloy
language: English
hints: []
pronounce: []
SWAIG:
defaults:
web_hook_url: https://example.com/swaig
native_functions: []
includes:
- url: https://example.com/swaig
functions:
- search_movie
- get_movie_details
- discover_movies
- get_trending_movies
- get_movie_recommendations
- get_genre_list
- get_upcoming_movies
- get_similar_movies
- get_now_playing_movies
- multi_search
- get_person_detail
- get_movie_credits
functions: []version: 1.0.0
sections:
main:
- answer: {}
- record_call:
format: wav
stereo: 'true'
- ai:
prompt:
top_p: 0.6
temperature: 0.6
text: |
You're an expert mixologist and work as a bartender. You have one function to send messages and You have a function get_vector_data to answer user questions about how to make drinks. Only provide the user information from the get_vector_data function
# Step 1
Greet the user.
# Step 2
Ask the user what drink would you like to make today.
# Step 3
Tell the user the the answer to their question.
# Step 4
Ask the user if there is anything else you can help them with.
# Step 5
Offer to send the details in a message to the user. Keep assisting the user until the user is ready to end the call.
params:
verbose_logs: 'true'
post_prompt_url: optional.fake.tld
post_prompt:
top_p: 0.6
temperature: 0.6
text: |
Summarize the conversation and send the conversation as a message to the user in an anonymous json object.
# Step 1
languages:
- name: English
code: en-US
voice: alloy
fillers:
- one moment
- one moment please
engine: openai
hints:
- drinks
SWAIG:
defaults: {}
functions:
- function: send_message
purpose: use to send text messages to a user
argument:
type: object
properties:
to:
type: string
description: The user's number in e.164 format
message:
description: the message to send to the user
type: string
data_map:
expressions:
- string: ${args.message}
output:
response: Message sent.
action:
- SWML:
version: 1.0.0
sections:
main:
- send_sms:
to_number: ${args.to}
region: us
body: ${args.message}, ${chunks[0].text} ${chunks[0].document_id}
Reply STOP to stop.
from_number: '+15555555555'
pattern: .*
- function: get_vector_data
purpose: The question the user will ask
argument:
type: object
properties:
user_question:
type: string
description: 'The question the user will ask. Use url encoding
between words. for example: how%20are%20you'
data_map:
webhooks:
- url: https://space_name.signalwire.com/api/datasphere/documents/search
headers:
Content-Type: application/json
Authorization: Basic OGVhMjI0YzktM--USE--Project_ID:API_KEY--TO-BASE64-ENCODE--NkYjFh
output:
response: ' Use this information to answer the users query,
only provide answers from this information and do not make
up anything: ${chunks[0].text} and ${chunks[0].document_id}'
action: []
method: POST
params:
query_string: ${args.user_question}
document_id: 694ced7b-b656-417e-bc86-ce22549b4562
count: 1
fillers:
en-US:
- This is the get vector data function firingEnterprise-Friendly AI Superpowers
Evolve the Contact Center With Multi-Channel Conversational AI
Ensure your offering stays relevant as AI evolves. Build more advanced, capable AI agents and get them to market faster. Let us handle the hardest parts of the infrastructure.
Frequently Asked Questions
SignalWire makes it much easier and faster to build, deploy, and scale teams of conversational AI Agents that can work across channels and handle support and sales interactions that require multiple steps to resolve.
How? While the leading platforms do offer multiple channels, they are loosely integrated. Unifying them into a coherent flow would require significant development resources….and that’s before AI enters the picture.
SignalWire unifies voice, text messaging, video conferencing, and AI into single, declarative markup language that web developers can quickly master.
Every other voice AI platform uses Twilio, Vonage, or another telco platform for telephony.
Most of them can only support a single channel. If they support traditional phone calls, they'll have limited support for SIP and WebRTC. If they support WebRTC, their SIP and PSTN interfaces will be full of latency.
If they do include SMS, MMS, RCS for text messaging, it’s usually one way (for notifications) rather than two-way conversations.
They will all struggle mightily if they try to support video.
SignalWire built and runs its own multi-channel communications stack. We natively integrated AI in 2024. Every SignalWire node supports voice (PSTN, WebRTC, SIP), two-way text messaging (SMS, MMS, RCS) and video conferencing (WebRTC, SIP).
Similarly, conversational AI / LLM chatbot platforms were built for text chat. The most advanced of them have integrated OpenAI’s realtime API with WebRTC or SIP. These, too, will struggle to support real time AI agents that can work across voice, messaging, video interactions without losing context or going off role.
With SignalWire, you can build whole teams of AI agents that have different skills and handle different channels...and orchestrate them with another agent that routes calls to each one.
Or you can design a single agent that takes on different roles, activates different skills, and uses different channels based on data in your CRM and the caller's requests.
You can structure multi-step conversations that only advance when the "goal" of the step is complete. OR you can build multiple possible conversation paths and navigate between them.
Yes! You can route calls to your SignalWire agents from all major contact center platforms and any phone system that supports SIP.
You can use your own PBX to route calls to SignalWire Agents AND you can configure SignalWire agents to receive calls and transfer them to any SIP address or phone number.
Absolutely! With the SignalWire AI Gateway (SWAIG), developers can give your agents access to any API, database, or external system. It’s as easy as integrating them into a web app.
Most AI platforms require you to set up and scale your own servers and microservices to handle these integrations. With SignalWire, these integrations run natively and trigger directly from the call logic, so there’s no additional servers or microservices to stand up and scale.
That boils down to less latency, more control over call flows, faster time to market, and far less DevOps work to scale your advanced agents.
Generally, yes.
Unless the external system has an extremely responsive API, accessing third party integrations on a live call can generate additional latency.
But our unique approach to integrating other systems without servers minimizes the impact. We also makes it very easy to prompt the agent to fill the pauses with a range of natural expressions or questions: (”Let me see if there’s a table available at on Friday! While I do look that up, do have any allergies you’d like the restaurant to know about?”)
Yes!
Unlike other platforms that require you to configure and scale multiple tools to transcribe calls as they happen, SignalWire makes it as simple as adding a debug webhook and fetching the transcrptions as they unfold.
Definitely. With live_translate, you can translate between languages in real time with the same level of latency you’d expect if a professional human translator was doing the job. You can also build multi-lingual agents that can switch between a pre-defined set of languages, voices, and accents upon request.