The evolution of IVRs: Reimagining call control from the ground up

When FreeSWITCH was first developed, one of many goals was to make better IVRs. But that goal meant addressing deep-rooted challenges in traditional telephony.

At the time, existing solutions like Asterisk provided basic dialplans that were inflexible and difficult to scale. IVR systems were largely dependent on predefined scripts, limiting dynamic control over calls.

Developers struggled with static call routing that couldn’t adapt to real-time conditions, complex scripting requirements for handling inputs like DTMF or speech, and limited external control beyond what was baked into the core system.

FreeSWITCH was created to fix problems like these, taking an open-ended, modular approach to telephony software. This started with a regex-based ini file format, eventually evolving into XML-based dialplans that allowed for variable expansion, API execution, and seamless translations between call states.

But the real transformation happened when scripting and external control mechanisms were introduced.

The rise of embedded scripting and remote call control

FreeSWITCH didn't stop at XML-based dialplans. As developers pushed the boundaries of automation, it became clear that real-time, programmatic control was necessary. This led to two critical innovations:

Embedded scripting—Call control with dynamic programming

Instead of relying solely on static configurations, FreeSWITCH allowed developers to embed interpreters for Perl, Lua, Python, and JavaScript directly into the system.

These scripting languages could execute logic-driven call flows dynamically, modify calls in real time without precompiled instructions, and access external APIs for decision-making. For the first time, call automation wasn’t just following a script. It could adapt based on live data.

External control via Event Socket Layer

Embedded scripting was powerful, but developers needed a way to control FreeSWITCH externally. This led to the creation of the Event Socket Layer (ESL), a TCP-based remote control mechanism that allowed developers to interact with active calls dynamically from outside FreeSWITCH, modify call behavior based on external conditions (like CRM data or fraud detection), and build scalable applications without being bound to in-process scripting.

Together, these innovations made FreeSWITCH the most flexible open-source telephony platform available. But they also highlighted new challenges:

• Security and scalability were left up to the implementor

• Each developer had to build their own control logic for advanced use cases

• There was no unified framework for best practices

These gaps became the foundation for SignalWire.

SignalWire: The next evolution in programmable (unified) communications

Building programmable communication applications has always required trade-offs:

• Do you prioritize raw power and flexibility (like FreeSWITCH)?

• Or do you prioritize scalability and ease of use (like traditional CPaaS solutions)?

SignalWire was created by the same team who built FreeSWITCH to eliminate this trade-off. It combines the flexibility of FreeSWITCH with the scalability and security of a modern cloud platform, providing developers with programmable unified communications (PUC).

This new model provides tools and developer-friendly frameworks for building voice, video, messaging, and agentic AI applications. With SignalWire’s implementation of PUC, Call Fabric, complex telecom infrastructure is simplified into accessible building blocks called Resources. Resources include tools like SIP endpoints, video conferencing rooms, scripts, and FreeSWITCH connectors.

The philosophy of PUC led to RELAY and SWML—SignalWire’s answer to the missing pieces in traditional VoIP development.

SWML: A programmable, unified approach to IVRs, call control, and AI

What is SWML?

SignalWire Markup Language (SWML) is a JSON or YAML based declarative framework for call automation. It takes the best aspects of:

• XML dialplans (structured, precompiled call logic)

• ESL-style event handling (external real-time call control)

• CPaaS-style API flexibility (serverless, cloud-based execution)

SWML acts as a universal language for call automation, giving developers predefined methods that act as modular building blocks for IVRs, call routing, and agentic AI automation.

Here are some examples of how developers are using SWML to power modern voice applications:

AI-powered IVRs

Instead of static menus, SWML lets AI handle natural language interactions, directing callers based on intent rather than rigid option trees.

Dynamic call routing

Calls can be forwarded based on real-time CRM data, caller history, or even AI predictions.

Secure transactions

Support for PCI-compliant payment processing lets businesses collect sensitive data safely.

Multi-channel interactions

SWML allows you to handle voice, AI, and video seamlessly within a single framework.

This dramatically reduces development complexity, making it easier to build, test, and deploy applications compared to traditional FreeSWITCH scripting.

AI in IVRs: The future of conversational call automation

As AI-powered voice interactions become more sophisticated and commonplace, the next challenge is integrating AI directly into the telephony stack.

Historically, building an AI IVR meant setting up a separate AI chatbot, writing middleware to bridge it with telephony systems, and handling speech recognition, DTMF input, and memory retention manually. This process is time-consuming and error-prone.

SWML makes AI call automation simple because with SignalWire, AI isn’t an external system. It’s built into the core architecture.

AI is just a method in SWML. The ai method allows AI-powered conversations to control call flows without needing custom infrastructure. The AI models can interact with call audio, speech recognition, and contextual memory natively within SignalWire.

AI can also engage with programmable behaviors such as:

• Send DTMF input

• Play pre-recorded audio

• Enter secure payment collection mode

• Dynamically adjust responses based on conversation context

In addition, SWML itself is embedded within the media stack, ensuring that call control, automation, and AI interactions happen natively inside the infrastructure.

FreeSWITCH vs. SignalWire: IVR evolution at a glance

The evolution from early FreeSWITCH IVR experiments to SignalWire’s AI call automation represents a paradigm shift in programmable communications.

FreeSWITCH gives developers raw control over telephony, but scaling it requires specialized expertise. SignalWire eliminates this friction, giving users a scalable, cloud-native way to build IVRs, AI agents, and advanced call automation. Meanwhile, SWML unifies everything, offering a structured, easy-to-use framework for call control, event handling, and AI.

The FreeSWITCH dialplan, reimagined

The goal of SignalWire is not to replace FreeSWITCH, but to build on its strengths while solving modern challenges like AI integration. While FreeSWITCH pioneered XML-based dialplans, SignalWire has moved forward with SWML.

For developers who have built IVRs using FreeSWITCH, SWML feels familiar. Building an AI IVR from scratch takes years of effort, but if you’re using FreeSWITCH today, SignalWire is the natural next step for scaling secure, AI-powered call flows.

FreeSWITCH remains a powerful engine for telephony. But the future lies in scalable, AI-powered systems. SignalWire extends what FreeSWITCH started by offering cloud-native solutions, declarative, API-driven call control, and AI agents.

Try the Sigmond AI demo at SignalWire AI and explore SWML firsthand to build the next generation of intelligent voice applications with ease.

The future of telephony is programmable. The future of telephony is SignalWire. Join our developer community on Discord to keep up with the conversation and latest developments.