# 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

```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.