Stop Reconstructing Call State From Webhooks.

Twilio webhooks are stateless. You rebuild context on every request. SignalWire is Twilio-compatible at the API level, and native interfaces eliminate webhook state management entirely.

The Webhook Problem

Race Conditions Are Not Bugs. They Are Architecture.

Zombie Calls

A hangup webhook arrives after a transfer command. The call is live with no tracking while your state store says it ended.

Double Updates

Concurrent webhooks read the same state, both mutate it, and the last write silently wins.

Phantom Transfers

A transfer target answers during a network partition while your state still shows ringing.

Stale Responses

The caller interrupts while the LLM generates, but the old response plays because cancellation followed a different path.

Build a Voice AI Agent

Python

from signalwire import AgentBase
from signalwire.core.function_result import FunctionResult

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 FunctionResult(f"Order {order_id}: shipped, ETA April 2nd")

agent = SupportAgent()
agent.run()

Webhook State Reconstruction vs. Platform-Native State

Twilio (Webhook State Reconstruction)

• Separate telephony, STT, TTS, and LLM providers, each with its own SDK
• Your glue code manages state across all four services
• Each vendor adds a separate queue, invoice, and escalation path
• Compliance and observability must be rebuilt across every vendor
• 16 to 23 months before a production call

SignalWire (Platform-Native State)

• Telephony, STT, TTS, and LLM in one platform
• AI runs inside the media stack, not outside it
• 800–1200ms typical response latency
• One vendor, one invoice, one escalation path
• Production calls in four to six weeks
• State management is platform-native

Migration Path

Day 1: Install and build your first agent

Install signalwire-agents, define your agent class, add a prompt, and make your first phone call to a working AI agent.

Weeks 1–2: Connect your business logic

Add tool functions that call your backend: order lookups, appointment scheduling, account verification, and the tools that differentiate your product.

Weeks 2–3: Structure conversation flow

Define steps with scoped prompts and scoped tools. Each step handles one phase of the conversation with focused context.

Weeks 4–6: Go live

Deploy your agent as a standard HTTP microservice. Provision phone numbers, route calls, and move into production.

Weeks 3–4: Test and iterate

Test with real calls. Iterate on prompts and flows. Use the sandbox environment for rapid development cycles.

Sigmond Runs on SignalWire

A voice and video AI agent built on the SignalWire SDK, wired to a live knowledge base, able to see what you show him. Build the same thing on voice, phone, WhatsApp, or SIP, or an entire white-label platform with SignalWire as the network underneath.

Migrate From Webhooks to a Real Control Plane

Start with Twilio-compatible APIs. Graduate to platform-native capabilities at your own pace.