Programmable Unified Communications: The Solution 🔗

When we set out to build SignalWire, we didn't just want to create another CPaaS. We wanted to fundamentally rethink how developers interact with communication infrastructure. The result is Programmable Unified Communications (PUC), a new paradigm that treats all forms of communication as composable, programmable resources.

What Makes PUC Different 🔗

Traditional platforms give you APIs to control individual communication channels. PUC gives you a unified abstraction layer that works across all channels. Think of it like the difference between assembly language and Python: both can accomplish the same tasks, but one is dramatically more productive.

At the heart of PUC is Call Fabric, our implementation that provides:

Composable Resources 🔗

Just like modern web applications are built from composable components, Call Fabric provides building blocks:

• Rooms: Scalable spaces for audio/video conferencing
• Subscribers: Authenticated endpoints (SIP, mobile apps, browsers)
• Scripts: SWML documents that define workflows and logic
• AI Agents: Intelligent assistants that can handle conversations
• Queues: Dynamic routing based on skills, time, or custom logic

These aren't just features; they're resources you can mix, match, and orchestrate in real-time.

Familiar Addressing 🔗

Every resource in Call Fabric has a simple address:

space_name.signalwire.com/context/address

Just like web URLs, these addresses are intuitive and predictable. A subscriber named "Alice" in the public context is simply /public/Alice. This familiarity accelerates development and reduces cognitive load.

SWML: The Language of Unified Communications 🔗

SignalWire Markup Language (SWML) is where the magic happens. Starting as a way to define call flows, SWML has evolved into a complete orchestration language for conversational AI:

version: 1.0.0
sections:
  main:

    - ai:
        prompt:
          text: |
            You are a helpful customer service agent.
            Assist customers with their inquiries.
        post_prompt_url: https://example.com/conversation-summary
        swaig:
          functions:

            - get_customer_info
            - create_ticket
            - transfer_to_human

But here's the key innovation: SWML isn't just configuration. It's a living document that can be modified in real-time. Need to update the AI's behavior during a conversation? Change the SWML. Want to add new capabilities? Update the functions. No restarts, no downtime, no complexity.

The Power of Native Integration 🔗

Because SWML is native to our platform, not bolted on, we can do things that are impossible with traditional approaches:

• Instant Updates: Modify agent behavior mid-conversation
• Context Preservation: State flows naturally between resources
• Unified Events: One event stream across all channels
• Intelligent Routing: AI-driven decisions at the infrastructure level

This is the difference between integration and true unification. Every component knows about every other component. The platform itself becomes intelligent.