We are so excited for our upcoming event, and we have an amazing list of people helping us make the event as brilliant as it's going to be. Those people include this year's speakers, the first of which we are going to introduce you to in this blog.
Alanna
- Thu May 14 2026
CommCon 2026 speakers: Part 1
VoiceBlender is an open-source Go service that fuses SIP, WebRTC, and AI into a single real-time audio pipeline. It lets you spin up multi-party voice sessions, drop AI agents into live calls mid-conversation, and control everything through a simple REST API - no PBC required.
In this talk we'll walk through the architecture behind a system that treats a phone call and an AI agent as equal participants in the same audio mix. We'll explore the trade-offs of doing real-time media in Go, how to make legacy telephony and modern AI provider speak the same language, and why answering machine detection is still a surprisingly hard signal-processing problem in 2026.
You'll leave with a working mental model for building outbound dialers, AI-powered IVRs, and real-time voice agents - entirely in Go.
I will walk through the key steps for migrating a media server, including requirement gathering, evaluating media server options, planning, implementation and testing.
I will explain it from the perspective of a migration project we performed for a real-time production application for a client. The aforementioned application had multiple features, like conference and webinar rooms, a cell center with IVR, outbound calls, recordings, and live transcription and translation, which makes a migration more complex than a basic meeting application. In this case, we migrated from Kurento to LiveKit, making use of the LiveKit Agents framework to integrate with AI agents for some of the workflow (call center solution and live transcription and translation).
This migration simplified the architecture and application, fixed some of the issues the previous one had, improved the performance both client side (while in a meeting) and server side (less resources used), made it more scalable (can handle many more and way bigger meetings) and allows us to easily integrate with more modern AI solutions.
One of the most interesting ongoing efforts in the standardization activities is MoQ, which is an attempt to provide a low-latency media delivery solution for ingest/distribution of media over QUIC. It does provide some overlap with WebRTC functionality, especially considering that many are looking at is as a way to overcome some of what they perceive may be limitations or constraints in how WebRTC does things.
As a person familiar with WebRTC for a long time, I was very interested in studying MoQ as well, to investigate the main target scenarios and how the specification plans to address them. This presentation will provide a brief introduction to MoQ itself and its architecture, and will then focus a bit more on parallels between MoQ and WebRTC, where available/applicable, and the associated challenges and opportunities. I will also share some implementation feedback, drawing from my experience writing a POC gateway implementation between MoQ (using the imquic library) and WebRTC (using the Janus WebRTC Server).
Traditional PBX systems lock call routing logic inside proprietary configuration languages or complex dialplan scripts. DragonPBX takes a different approach: it's a B2BUA that sits in the middle of every call, using Drachtio for SIP signalling and RTPEngine for media, but delegates all routing decisions to external HTTP endpoints via webhooks.
When a call arrives, DragonPBX authenticates the source, matches it against a dial plan, and fetches a CallScript - a simple JSON array of verbs like "announce", "connect", "response", and "pause" - from your web service. Your call logic can be written in any language, hosted anywhere, and changed without restarting the PBX.
In this 20-minute talk, I'll cover:
- Background - why I decided to create DragonPBX and how it's different to other api platforms like Jambonz, Twilio and Vonage
- Architecture overview - how Drachtio, RTPEngine, Redis, and your HTTP services fit together
- Endpoints: clients and trunks - how SIP phones register and how trunk connections to carriers work, including IP auth, digest auth, and outbound registration
- CallScript verbs - the JSON vocabulary for controlling calls, with examples
- Live demo - setting up DragonPBX, registering a couple of phones, and making calls routed by a simple HTTP service
Whether you're a telco developer, a VoIP integrator, or just frustrated with existing PBX options, this talk will show you a modern, developer-friendly alternative where the web is your dialplan.
Telecom platforms are increasingly expected to support real-time AI interactions, yet most implementations rely on CPaaS abstractions that hide the underlying call mechanics.
This session presents a practical implementation of a WhatsApp voice integration built on SIP, using Kamailio as the core.
We start with the signaling and media layer:
- Handling WhatsApp voice calls via Meta's gateways
- Managing RTP streams and media flow
- Implementing routing logic, authentication, and CDR generation in Kamailio
On top of this, we introduce an open source AI voice service integrated as a SIP endpoint:
- Real-time RTP stream capture
- Streaming audio to STT services
- Processing with an LLM
- Returning synthesized speech (TTS) into the live call
We will discuss different service examples and also present learnings from real-world usage of the service.
We needed a safe place to test VoIP and WebRTC attacks without breaking production systems or ending up in legal trouble. So we built Damn Vulnerable Real-Time Communications (DVRTC), an intentionally insecure platform using Kamailio, Asterisk, and rtpengine.
This talk focuses on the WebRTC conferencing scenario we've added to DVRTC. I'll cover the vulnerabilities we implemented, how we configured things to be deliberately broken while still being realistic, and demo some of the attacks.
If you run or build WebRTC infrastructure, this is a look at what keeps showing up in our penetration tests.
Back in 2019, we set out to replace an aging telephony platform with a system ready for future demands. What seemed straightforward quickly turned into a complex endeavour: building for high traffic, ensuring high availability, implementing advanced telco features, and complying with regulatory constraints.
Throughout this journey, we not only tackled technical challenges but also discovered new opportunities, including the integration of AI into our platform. This talk walks through the evolution of the system, the decisions we made, and the lessons we learned along the way.
Building one AI agent using either a conventional pipeline, or realtime multimedia agent has never been easier. Lots of really great choices from buying the whole agent as a cloud service from a single provider through to building using Open Source and plugging it in yourself from the GPU up.
This talk is a practical perspective on integrating different providers and agent technology resiliently into telecoms networks using tools like Kamailio SBCs or Freeswitch as a BSBUA, to optimise resilient trunk access and build arrays of AI agents as registration clients at scale.
We also touch on agent observability and interaction quality monitoring for commercial SLA compliance.
There are some fascinating talks here, and the finest in the industry are sharing their expertise with us. We're so excited to hear all of these talks, and we have more to share with you in the coming days.
If you want to here those talks, head over to our ticket page to secure your spot at the conference.
See you there
- Team CommCon
