One AI Agent, Every Channel: Voice, SMS, and Web

AI agent channels are the ways a single agent can be reached -- by phone call, by text message, or through a web link -- without you building a separate bot for each. In Deelo a channel is an input/output adapter sitting over one unchanged agent: the same brain, the same tools, the same permissions, and the same guardrails answer a voice call, an SMS, and a web chat. What changes between channels is only how the message arrives and how the reply is delivered. Build the agent once; meet customers wherever they already are.

The default way businesses end up multi-channel is by accident: a phone bot from one vendor, a website chat widget from another, an SMS tool bolted on a year later. Three systems, three sets of instructions, three things to update when your return policy changes -- and three subtly different answers to the same question, because nobody kept them in sync.

The sane way treats the channel as plumbing, not personality. There's one agent that knows your business, and the phone line, the text thread, and the web widget are just doors into it. Change the policy once and every door reflects it, because there's only ever one agent behind them. That's the model here, and it's a deliberate architectural choice, not a bundle of three products wearing one name.

Under the hood, the agent runtime -- the loop that reads context, calls tools, and produces a reply -- is completely channel-agnostic. It doesn't know or care whether a request came from a phone or a browser. A channel adapter handles four things and nothing more: the transport (a Twilio call versus a web request), how a conversation is kept together across turns, how the reply is rendered for that medium, and what it takes to switch the channel on.

The payoff of that separation is consistency you don't have to maintain. The agent resolves the same tools, runs through the same permission grid, and hits the same approval gates on every channel, because it's literally the same code path. A guardrail you set once holds on the phone, in a text, and on the web -- not because three systems were configured to agree, but because there's only one system. It also means improving the agent is a single edit: sharpen its instructions or widen its tools, and every channel gets the upgrade at once. There's no drift to reconcile later, because there was never more than one agent to drift.

Deelo ships three channels today, and they differ mainly in how a conversation reaches the agent and what you need to switch them on. The agent behind them is identical; what follows is the practical shape of each -- who starts the conversation, and what it takes to run it.

Because every channel runs the one agent, your governance doesn't fork. Every turn is metered in credits and fails closed if the balance is gone. Exactly-once dispatch means a network hiccup can't make a phone agent send the same text twice. And the high-risk floor holds everywhere: if a caller or a web visitor asks for something that moves money, touches protected data, or sends externally, the agent won't just do it.

Instead it uses defer-and-report. The agent does the safe part of the request, gathers the details, and records the ask for your team rather than letting an outside party approve a risky action -- it writes a durable event your automations can act on and sends an in-app notification to the agent's owner. On a voice call, if you've configured a fallback number, it can warm-transfer the caller to a real person instead. An anonymous stranger can create a task in your queue; they can never trigger the action itself.

A public web agent is a different trust situation from an internal one -- anyone on the internet can talk to it, including someone trying to talk it into misbehaving. So the public web channel defaults to a read-only posture: the agent can look things up and answer from its knowledge, but the write, send, and delete tools are stripped from that surface until you deliberately opt up. You narrow, then widen -- the safe direction.

This is a channel-level restriction layered on top of the agent's own permissions, so you can run the exact same agent internally with full write access and publicly in read-only mode, without maintaining two agents. It's the difference between a shareable agent that's safe to hand a stranger and one you'd never dare publish.

The right channel is wherever your customers already reach out. A trades business drowning in after-hours calls wants voice. A clinic chasing no-shows wants SMS. A SaaS site fielding the same pre-sales questions wants a web agent on the pricing page. Most businesses eventually want more than one -- and since it's the same agent underneath, adding a channel is switching one on, not building another bot.

Start with the loudest channel, get the agent right there, and expand. The setup specifics live in how to set up an AI SMS agent and how to add an AI agent to your website; the safety design behind the deferrals is in human-in-the-loop AI agents; and Deelo Voice is where the phone side lives.