Keep Your AI. Replace What Holds It Back.

2,000+

companies in production

< 1.2s

typical AI response latency

2.7B

minutes processed annually

$0.16

per minute, AI processing

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.

The Vendor Chain Problem

Your AI Is Only as Fast as the Slowest Vendor

Every vendor adds latency

Your stack routes audio through a telephony provider, an STT provider, an LLM, and a TTS provider. Each hop adds 100-300ms. Four hops turn a fast LLM into a slow conversation.

Every vendor adds a failure mode

When the call drops at 2am, who gets the ticket? The telephony provider, the STT vendor, or the TTS vendor? Debugging across four dashboards is the real cost.

State splits across systems

Conversation context lives in webhooks, Redis, and vendor callbacks. Transfers lose context because no single system owns the call state.

Costs compound through the chain

Each vendor marks up the layer below it. A four-vendor stack means four margins stacked on top of carrier costs.

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();
}

Multi-Vendor Stack vs. One Platform

Current: Multi-Vendor Stack

Telephony provider for numbers and PSTN
Separate STT provider
Separate TTS provider
LLM provider with token billing
Your glue code connecting all four
Every vendor adds latency and cost

SignalWire: One Platform

Phone numbers, SIP, PSTN, media streaming included
STT and TTS run inside the AI processing engine
AI executes inside the media stack
One invoice, sub-second latency
Your AI logic stays the same
Replace telephony first, consolidate AI when ready

Monthly Cost at 10,000 Minutes

Component	Multi-Vendor Stack	SignalWire
Transport (PSTN/SIP)	$130-220	Carrier rates (separate)
Orchestration middleware	$500-2,000	Included
STT provider	$400-800	Included
LLM provider	$1,000-4,000+	Included
TTS provider	$500-2,000	Included
Total	$2,530-9,020	$1,600

We replaced the telephony layer first. Latency dropped, costs dropped, and we stopped debugging three vendor dashboards at 2am. Six months later we moved everything onto one platform.

Composite scenario based on customer migration experiences

Migration Path: Move at Your Own Pace

1

Phase 1: Replace telephony

Point your existing system at SignalWire for phone numbers and PSTN. Your AI orchestration stays unchanged. Immediate cost savings and lower latency.

2

Phase 2: Consolidate AI processing

Move STT and TTS onto the platform. Eliminate separate provider SDKs and invoices. Reduce network hops and latency.

3

Phase 3: Full platform

Move your agent logic to the Python SDK. One stack, one vendor, sub-second latency. Scoped prompts and tools per conversation step.

Each phase is independent Every phase delivers value on its own. You do not need to commit to the full migration to benefit from replacing the telephony layer.

FAQ

Can I keep my existing AI orchestration layer?

Yes. Phase 1 replaces only the telephony provider. Your AI logic, agent definitions, and conversation flows stay the same.

How does the migration work with existing phone numbers?

Provision new numbers via API or dashboard, or port existing numbers from your current provider. Typical US porting takes 5-10 business days with no downtime.

What if I use an orchestration tool like Vapi or Retell?

SignalWire replaces the telephony underneath your orchestration layer. Your agent definitions stay the same. Better latency and lower cost from day one.

What does $0.16 per minute include?

AI processing: STT, LLM inference, TTS, and orchestration. Transport (SIP, PSTN) is billed separately at carrier rates. One invoice. Billing counts AI processing time, not total call time.

Is there a standard SIP integration?

Yes. Standards-compliant SIP with full codec support, DTMF, and encrypted media. Built on the same engine that powers major carriers and contact center platforms.

Trusted by 2,000+ companies

Keep your AI. Replace what holds it back.

Better latency, lower cost, and a path to the full platform when you are ready.

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

Keep Your AI. Replace What's Underneath.