FreeSWITCH Heritage: Two Decades of Voice Infrastructure

2.7B

minutes and messages annually

2,000+

companies in production

20 years

continuous development

< 1.2s

typical AI response latency

Try it now

Talk it through with Sigmond

Sigmond is a voice AI agent running on the SignalWire infrastructure this page is about. Ask him about anything you just read.

Why Heritage Matters

Voice Infrastructure Is a Solved Problem (If You Built It)

Media Stack Ownership

The team wrote the media processing engine that powers voice networks worldwide. They can modify the codec pipeline, tune endpointing, and embed AI at the audio frame level. No vendor API stands in the way.

Known Failure Modes

Two decades of production telephony means the edge cases are catalogued: codec negotiation failures, overbuffered audio, overburdened endpoints, overbilled calls. The platform handles them because the team has seen them.

Engine-Level AI

When voice AI emerged, the team embedded orchestration directly in the media stack. The AI kernel coordinates speech recognition, language model inference, and speech synthesis with direct access to the audio stream, eliminating the orchestration overhead of bolt-on pipelines.

End-to-End Changes

When something needs optimization, one team modifies one codebase. No vendor ticket. No API limitation. No waiting for someone else's roadmap.

Bolt-On AI vs. Embedded AI Kernel

Bolt-On Architecture

Audio routes out to STT, then LLM, then TTS, then back
Each vendor adds latency and a failure mode
Barge-in detection happens after network round-trips
Error recovery requires per-vendor retry logic
State management is your application's problem

Embedded AI Kernel

STT, LLM, and TTS orchestrated from inside the media stack
800-1200ms typical response latency, orchestration overhead eliminated
Barge-in detection at the media frame level
Unified error taxonomy with automatic recovery
State is a platform property, not your code

Build a Voice AI Agent

from signalwire_agents import AgentBase
from signalwire_agents.core.function_result import SwaigFunctionResult

class SupportAgent(AgentBase):
    def __init__(self):
        super().__init__(name="Support Agent", route="/support")
        self.prompt_add_section("Instructions",
            body="You are a customer support agent. "
                 "Greet the caller and resolve their issue.")
        self.add_language("English", "en-US", "rime.spore:mistv2")

    @AgentBase.tool(name="check_order")
    def check_order(self, order_id: str):
        """Check the status of a customer order.

        Args:
            order_id: The order ID to look up
        """
        return SwaigFunctionResult(f"Order {order_id}: shipped, ETA April 2nd")

agent = SupportAgent()
agent.run()

import { AgentBase, FunctionResult } from '@signalwire/sdk';

const agent = new AgentBase({
  name: 'Support Agent',
  route: '/support',
});

agent.promptAddSection('Instructions',
  'You are a customer support agent. Greet the caller and resolve their issue.');

agent.addLanguage({ name: 'English', code: 'en-US', voice: 'rime.spore:mistv2' });

agent.defineTool({
  name: 'check_order',
  description: 'Check the status of a customer order',
  parameters: {
    type: 'object',
    properties: {
      order_id: { type: 'string', description: 'The order ID to look up' },
    },
    required: ['order_id'],
  },
  handler: (args) => {
    return new FunctionResult(`Order ${args.order_id}: shipped, ETA April 2nd`);
  },
});

agent.run();

package main

import (
	"fmt"

	"github.com/signalwire/signalwire-go/pkg/agent"
	"github.com/signalwire/signalwire-go/pkg/swaig"
)

func main() {
	a := agent.NewAgentBase(
		agent.WithName("Support Agent"),
		agent.WithRoute("/support"),
	)

	a.PromptAddSection("Instructions",
		"You are a customer support agent. Greet the caller and resolve their issue.")

	a.AddLanguage(map[string]any{
		"name": "English", "code": "en-US", "voice": "rime.spore:mistv2",
	})

	a.DefineTool(agent.ToolDefinition{
		Name:        "check_order",
		Description: "Check the status of a customer order",
		Parameters: map[string]any{
			"type": "object",
			"properties": map[string]any{
				"order_id": map[string]any{
					"type": "string", "description": "The order ID to look up",
				},
			},
			"required": []string{"order_id"},
		},
		Handler: func(args map[string]any, rawData map[string]any) *swaig.FunctionResult {
			orderID := args["order_id"]
			return swaig.NewFunctionResult(
				fmt.Sprintf("Order %v: shipped, ETA April 2nd", orderID),
			)
		},
	})

	a.Run()
}

import com.signalwire.sdk.agent.AgentBase;
import com.signalwire.sdk.swaig.FunctionResult;

import java.util.List;
import java.util.Map;

public class SupportAgent {
    public static void main(String[] args) throws Exception {
        var agent = AgentBase.builder()
                .name("Support Agent")
                .route("/support")
                .build();

        agent.promptAddSection("Instructions",
                "You are a customer support agent. "
              + "Greet the caller and resolve their issue.");

        agent.addLanguage("English", "en-US", "rime.spore:mistv2");

        agent.defineTool(
                "check_order",
                "Check the status of a customer order",
                Map.of("type", "object",
                       "properties", Map.of(
                           "order_id", Map.of(
                               "type", "string",
                               "description", "The order ID to look up")),
                       "required", List.of("order_id")),
                (toolArgs, rawData) -> {
                    var orderId = toolArgs.get("order_id");
                    return new FunctionResult(
                        "Order " + orderId + ": shipped, ETA April 2nd");
                }
        );

        agent.run();
    }
}

# frozen_string_literal: true

require 'signalwire'

agent = SignalWire::AgentBase.new(name: 'Support Agent', route: '/support')

agent.prompt_add_section('Instructions',
  'You are a customer support agent. Greet the caller and resolve their issue.')

agent.add_language(name: 'English', code: 'en-US', voice: 'rime.spore:mistv2')

agent.define_tool(
  name:        'check_order',
  description: 'Check the status of a customer order',
  parameters:  {
    'order_id' => { 'type' => 'string', 'description' => 'The order ID to look up' }
  }
) do |args, _raw|
  SignalWire::Swaig::FunctionResult.new(
    "Order #{args['order_id']}: shipped, ETA April 2nd"
  )
end

agent.run

<?php
require 'vendor/autoload.php';

use SignalWire\Agent\AgentBase;
use SignalWire\SWAIG\FunctionResult;

$agent = new AgentBase(['name' => 'Support Agent', 'route' => '/support']);

$agent->promptAddSection('Instructions',
    'You are a customer support agent. Greet the caller and resolve their issue.');

$agent->addLanguage('English', 'en-US', 'rime.spore:mistv2');

$agent->defineTool(
    name: 'check_order',
    description: 'Check the status of a customer order',
    parameters: [
        'order_id' => ['type' => 'string', 'description' => 'The order ID to look up'],
    ],
    handler: function (array $args): FunctionResult {
        return new FunctionResult("Order {$args['order_id']}: shipped, ETA April 2nd");
    }
);

$agent->run();

#!/usr/bin/env perl
use strict;
use warnings;
use lib 'lib';
use SignalWire::Agent::AgentBase;
use SignalWire::SWAIG::FunctionResult;

my $agent = SignalWire::Agent::AgentBase->new(
    name  => 'Support Agent',
    route => '/support',
);

$agent->prompt_add_section('Instructions',
    'You are a customer support agent. Greet the caller and resolve their issue.');

$agent->add_language(name => 'English', code => 'en-US', voice => 'rime.spore:mistv2');

$agent->define_tool(
    name        => 'check_order',
    description => 'Check the status of a customer order',
    parameters  => {
        order_id => { type => 'string', description => 'The order ID to look up' },
    },
    handler => sub {
        my ($args, $raw) = @_;
        return SignalWire::SWAIG::FunctionResult->new(
            response => "Order $args->{order_id}: shipped, ETA April 2nd"
        );
    },
);

$agent->run;

#include <signalwire/agent/agent_base.hpp>

using namespace signalwire;
using json = nlohmann::json;

class SupportAgent : public agent::AgentBase {
public:
    SupportAgent() : AgentBase("Support Agent", "/support") {
        prompt_add_section("Instructions",
            "You are a customer support agent. "
            "Greet the caller and resolve their issue.");

        add_language({"English", "en-US", "rime.spore:mistv2"});

        define_tool({
            .name = "check_order",
            .description = "Check the status of a customer order",
            .parameters = {
                {"order_id", {{"type", "string"},
                              {"description", "The order ID to look up"}}}
            },
            .handler = [](const json& args, const json&) {
                auto order_id = args.value("order_id", "unknown");
                return swaig::FunctionResult(
                    "Order " + order_id + ": shipped, ETA April 2nd");
            }
        });
    }
};

int main() {
    SupportAgent().run();
}

using SignalWire.Agent;
using SignalWire.SWAIG;

var agent = new AgentBase(new AgentOptions { Name = "Support Agent", Route = "/support" });

agent.PromptAddSection("Instructions",
    "You are a customer support agent. Greet the caller and resolve their issue.");

agent.AddLanguage("English", "en-US", "rime.spore:mistv2");

agent.DefineTool("check_order", "Check the status of a customer order",
    new { type = "object", properties = new {
        order_id = new { type = "string", description = "The order ID to look up" }
    }, required = new[] { "order_id" } },
    (args, rawData) =>
    {
        var orderId = args.TryGetValue("order_id", out var id) ? id : "unknown";
        return new FunctionResult($"Order {orderId}: shipped, ETA April 2nd");
    });

agent.Run();

use signalwire::agent::AgentBase;
use signalwire::swaig::FunctionResult;
use serde_json::json;

fn main() {
    let mut agent = AgentBase::builder()
        .name("Support Agent")
        .route("/support")
        .build();

    agent
        .prompt_add_section("Instructions",
            "You are a customer support agent. Greet the caller and resolve their issue.", &[])
        .add_language("English", "en-US", "rime.spore:mistv2");

    agent.define_tool(
        "check_order",
        "Check the status of a customer order",
        json!({"type": "object", "properties": {
            "order_id": {"type": "string", "description": "The order ID to look up"}
        }, "required": ["order_id"]}),
        Box::new(|args, _raw| {
            let order_id = args.get("order_id").and_then(|v| v.as_str()).unwrap_or("unknown");
            FunctionResult::with_response(&format!("Order {order_id}: shipped, ETA April 2nd"))
        }),
    );

    agent.run();
}

From Open-Source Engine to Cloud Platform

2006: FreeSWITCH Created

Open-source telephony engine adopted by carriers, contact centers, and UCaaS platforms worldwide.

2018: Real-Time WebSocket Control

Persistent session control infrastructure built years before voice AI existed as a category.

2020: Cloud Platform Launch

Managed infrastructure layer with state management, orchestration, billing, and security on top of the core engine.

2023: AI Kernel Embedded

C-based AI kernel orchestrating STT, LLM, and TTS from inside the media stack.

2024: Governed Inference

Production governance with scoped prompts, constrained tools, and enforced state machine transitions.

2025: Agents SDK

Python SDK for building, testing, and deploying voice AI agents as standard HTTP microservices.

What It Took to Build the Platform

Layer	What It Required
State management	Platform-native call state, conversation context, step transitions
Orchestration	Multi-agent coordination, transfer logic, queue management
AI kernel	STT, LLM, and TTS embedded in the media stack (C)
Reliability	Global redundancy, failover, health monitoring
Observability	Structured event streams, per-component latency, error taxonomy
Security	Tenant isolation, encryption, compliance frameworks
API surface	REST, declarative YAML, real-time WebSocket, function calling, SDKs

Open-Source Roots, Proprietary Platform FreeSWITCH is open source. Everything built on top is proprietary. A competitor could adopt FreeSWITCH. Replicating the platform layer above it would take years of engineering across state management, orchestration, AI integration, and carrier-grade reliability.

The infrastructure underneath your voice AI agent has processed trillions of minutes for some of the largest communication providers in the world. The failure modes are known. The edge cases are handled. The scaling patterns are proven.

SignalWire Engineering, Platform Architecture Team

FAQ

What is the relationship between FreeSWITCH and SignalWire?

FreeSWITCH is the open-source telephony engine. SignalWire was built by the same team as a managed cloud platform on top of FreeSWITCH. The AI kernel, state management, orchestration, and developer tools are all proprietary additions.

Why does owning the media stack matter for AI?

The AI kernel sits inside the media stack with direct access to the audio stream. It orchestrates speech recognition, language inference, and audio synthesis without the overhead of routing audio between separate external services. That is why response latency is 800-1200ms instead of 2-4 seconds. With speech-to-speech voice models, latency can be as low as 600ms.

Can I start with a declarative YAML agent and move to the Python SDK later?

Yes. YAML configuration and the Python SDK target the same platform. Start with YAML for rapid prototyping, then adopt the SDK for testing, composition, and programmatic control. Both interfaces compose.

How does pricing work?

$0.16 per minute covers AI processing: STT, LLM, and TTS. Transport (SIP, PSTN) is billed separately at carrier rates. One invoice. No per-token variance, no separate vendor bills.

Build on Two Decades of Voice Infrastructure

One pip install. The same engine that powers carrier-grade telephony worldwide.

Get Started Free Read the Docs

About SignalWire

SignalWire is a communications infrastructure platform. Voice, video, messaging, conferencing, queuing, recording, and AI all run on the same real-time voice and video substrate.

AI is one capability among many, not the whole business. Customers compose multiple services on a single carrier-billed call; margin expands as the service mix shifts toward higher-margin capabilities stacked on top of the transport layer.

The platform was built by the team that created FreeSWITCH. It processes 2.7 billion minutes and messages annually and is in production at 2,000+ companies, including Apple, Sprinklr, Deutsche Telekom, and T-Mobile.

Read the docs

Trillions of Minutes. Now With an AI Kernel.