Phone and voice in Connect
Connect answers your business number and places calls on it, on either of two engines: a turn-based carrier path that hears a sentence and reads a reply back, or a realtime speech-to-speech path where Connect holds the call itself. Both write the same calls record, obey the same autonomy and budget gates, and are configured from the Phone screen.
What the phone channel actually is#
Phone is a channel like email or WhatsApp: a number the business owns, a set of rules about who may be called and when, and a record of every conversation that a person and the engine can both read afterwards. What makes it different is that the conversation happens in real time, so decisions that email can defer — whether to answer, in what language, how long to wait before speaking — have to be made while somebody is holding a phone to their ear.
Three layers carry that. voice_carriers.py is the adapter and the only place a provider's own vocabulary appears — its signature scheme, its XML dialect, its webhook shape. telephony.py is the core: what a line is, what an event means, who may be called when. Everything above that — voice.py, the consoles, the Phone screen — names no provider at all, and a test asserts it rather than trusting it. Anything that needs to know whether recording or transfer exists asks telephony.can(provider, capability); branching on a provider's name is how a system ends up unable to remove that provider.
Two engines#
| Turn-based (carrier) | Realtime | |
|---|---|---|
| How it hears | The carrier transcribes a sentence and posts it to a webhook | A realtime model listens to the audio stream directly |
| How it speaks | Connect returns instructions the carrier reads out | The model speaks; the greeting is synthesised during the ring |
| Interruption | Not possible — a turn is a whole sentence | The caller can speak over the voice and be heard |
| Where it runs | voice.py and the carrier adapter | voice_engine.py plus the connect-voice worker on LiveKit |
| Turned on by | The default path for a line | Setting voice.engine = "realtime" on the workspace |
The engines are not two products. They write the same calls row, run the same end-of-call work — summary, lead, memory, follow-up — and pass outbound calls through the same gate, so consent, memory blocks, autonomy and budget apply identically. Choosing between them is a choice about how the conversation feels, not about what Connect is allowed to do.
What a workspace sets up#
- A number, claimed by the workspace as a line. See Your business number in Connect.
- Permissions and hours on that line, which decide whether it takes calls in, places them out, and when.
- An autonomy mode for the
voicechannel, which decides what Connect may do on a call without asking a person. - A voice and a behaviour, tuned in the Voice Lab and resolved per line, per purpose or per contact.
- A budget, because a live call is billed on audio tokens and a call that cannot be paid for is refused before it is answered.
Where the rest of this section is#
- Getting a call in
- How a call reaches your workspace, Carrier callback verification and Answering inbound calls.
- Getting a call out
- Placing outbound calls and, when nobody should be rung, Business hours and the closed line.
- What is written down
- The call record, Call transcripts, Call summaries and Call outcomes and dispositions.
- How the voice behaves
- The greeting, Barge-in, Turn detection and end of speech and Reply latency on a call.
- Running it
- The voice worker, Capacity and admission control, Phone line health and What a call costs.
What phone does not do#
Three things are deliberately absent, and no screen in Connect implies otherwise. Call recording is foundation: the capability is asked of the provider rather than assumed, and it is not enabled on the live carrier. A completed warm transfer to a human is foundation for the same reason — an escalation phrase queues a transfer and a colleague can act on a live call from the supervisor panel, but the handover itself depends on a provider capability that is not switched on. SMS on the live carrier does not exist at all, and the Phone screen's readiness section says so rather than showing a thread that could never send.
There is also a floor on how fast the realtime path can be. The model's first token plus its end-of-turn detection put the best measured call at a 3.3 s median reply, not the one to two seconds a demonstration video might suggest. Settings move that number; no setting removes it.
Everything in this section#
57 pages, each with its own status and the date it was last checked against the running system.
| Page | What it covers |
|---|---|
| A returning caller | The second time somebody rings: what Connect has already, how little of it reaches the conversation, and why continuity is not the same as recital. |
| Abandoned calls | Calls the caller walked away from: how the hang-up watcher recognises real abandonment, what it records, and why no closing line is spoken. |
| Answering inbound calls | From ring to greeting to first reply: the gates a caller passes, what they hear at each refusal, and what is written down while they talk. |
| Barge-in | Speaking over the voice on a live call: what stops it, the two-second rule that decides an interruption was ignored, and why the greeting is protected. |
| Business hours and the closed line | How opening hours are set on a line, what a caller hears outside them, and why the closed-line message never speaks the hours aloud. |
| Call outcomes and dispositions | The engine's outcome and a person's disposition are two columns answering two questions. What each one says, and how to use them together. |
| Call quality review | What a finished call is scored on: deterministic findings with the setting each one points at, the model's opinion kept separate, and limits that do not lower the score. |
| Call summaries | When a call summary is written, the two conditions under which Connect refuses to write one, and what a summary is allowed to contain. |
| Call transcripts | How a call transcript is assembled turn by turn, what the latency beside a reply actually measures, and the three things a transcript is not. |
| Calling from the browser | The browser line: a per-person SIP endpoint, why every state the dialler shows comes from a SIP event, and how a browser call actually makes a phone ring. |
| Calls that were never a conversation | no_answer, not_reached and silent failure are three different nothings. What each one means, how to tell them apart, and why none creates a lead. |
| Capacity and admission control | How admission decides a call can be taken: load per core, the 0.85 threshold, why a silent worker reads as free, and what saturation does to a caller. |
| Carrier callback verification | Why every carrier callback is signature-checked inside the owning workspace, what a replayed webhook looks like, and the index that stops one. |
| Configuring a phone line | The ten facts that make up a phone line, what each one refuses when it is set wrongly, and the order to decide them in. |
| Connect's own voice | Why the words a caller hears are synthesised by Connect rather than the carrier, how a sentence becomes a cached MP3, and the rule that forbids silence. |
| Consent on calls | Where consent for a phone call is decided, the single outbound path every call passes through, and why a block recorded elsewhere already applies to the phone. |
| Detecting the caller's language | What counts as proof a caller has changed language: four tiers with four different bars, the transcript artefacts that never count, and what pinning overrides. |
| Executing phone follow-ups | The drain that places a due call-back, the gates each one passes, the retry when no voice worker is ready, and the point at which a late follow-up is abandoned. |
| Facts learned on a call | What a phone call leaves behind in Memory, which extracted facts are refused outright, and how something heard on a call reaches a conversation on another channel. |
| Follow-ups from a call | How a spoken commitment on a call becomes a dated follow-up: the words that parse into a time, the channel it lands on, and the default when nothing parses. |
| Greeting warm-up | How Connect has the first sentence of a call already synthesised before the phone is picked up, and the quota refusal that once cost every restart its warm greeting. |
| How a call reaches your workspace | How a dialled number becomes a workspace, why every handler enters that workspace before reading a setting, and what an unclaimed number does. |
| Human voice profiles | One choice that yields a whole person: 86 parameters across identity, speech, imperfections and psychology, and the ones marked unsupported rather than faked. |
| Identifying the caller | Turning the number that rang into a person: the phone key, the rule when two records share a number, and what happens when nobody gives a name. |
| Leads captured from a call | When a phone call creates a Person and a lead, the two call endings that deliberately create nothing, and the key the record carries from the very first ring. |
| Light code-mixing and slang | Hinglish and light slang on a call: when a mixed sentence counts as evidence and when it does not, and what asking a model for a register achieves. |
| Multilingual calling | Calls held in more than one language: how the opening choice is made, what may change part-way through, and what a mixed sentence does. |
| Names heard on a call | What happens to a name spoken on a call: the protected markers, why a form of address never becomes one, and every door it must pass on the way in and out. |
| Phone for the Owner and for a customer | What the phone channel does identically for the operator and for a customer workspace, what a plan changes, and the small set of things that stay operator-only. |
| Phone line health | The four things line health reports about a phone line, what each one means for somebody ringing the number, and why none of them has to be cleared by hand. |
| Placing outbound calls | The five gates an outbound call passes before a number is dialled, what each refusal means, and how a call-back gets placed at all. |
| Promises made on a call | The rule that refuses a follow-up time the caller never said, what counts as agreeing to one, when a read-back is asked, and the finding for an empty promise. |
| Regional speaking style | The regional speaking-style layer: the prompt directions it adds, the things it cannot touch, and why a rendered cadence rule was removed rather than kept. |
| Remembering a caller's language | A caller's remembered speaking preference: where it is held, why Connect speaks it from the first reply, what overrides it, and what it costs in the brief. |
| Reply latency on a call | How long a caller waits for a reply: what the clock measures, where the floor comes from, and how to tell a slow reply from a slow model. |
| Session limits and long calls | The model's session cap, the context window, the provider cap and the product's own thirty-minute ceiling — which one ends a long call, and what a caller notices. |
| Silence and check-ins | What Connect does when nobody is speaking: how presence is tracked, why nothing is said over a caller, and what a silent stretch leaves on the record. |
| Steering a live call | The panel a colleague uses to steer a call in progress: why guidance never reaches the caller, and why pause, take over and release are read back out of the log. |
| Stuck calls and the sweep | Call rows left active by a worker that died or a browser call with no worker behind it, the sweep that closes them against the provider cap, and what it charges. |
| Switching the line off | What switching a phone line off does to a caller, to the call record and to work already scheduled on that line — and why it is not silence. |
| Telling the voice how to speak | The style block and the behaviour block: which settings become session parameters, which become instructions a model may only approximate, and which are neither. |
| The budget that stops a call | The budget question asked before an outbound call and before answering an inbound one, what a refused caller hears, and how the quota breaker differs from it. |
| The call brief | Everything assembled before a call starts: persona, purpose, contact facts, knowledge, rules and guidance — each with a character budget, and why the budgets exist. |
| The call record | Every field on a call: ring and answer times, provider status, cost, participants, quality, and why outcome and disposition are separate columns. |
| The carrier turn-based engine | The carrier webhook path — gather, reply, redirect — when it is the right engine for a line, and the three things it cannot do. |
| The greeting | How the first sentence of a call is chosen, why it is synthesised while the phone is still ringing, and what happens when it cannot be spoken. |
| The realtime voice engine | The speech-to-speech calling path: how a workspace turns it on, what the worker is given for each call, and what it is never allowed to know. |
| The response watchdog | The timer that asks a stalled model to answer: why its default is 5.5 seconds, what disarms it, and how a nudge can cancel the very reply it was waiting for. |
| The Voice Lab | The screen where a line's voice is tuned: engine settings that take effect exactly, steering text the model interprets, drafts and test calls. |
| The voice worker | The process that holds a realtime call: how it starts, what it heartbeats, how a deploy drains it, and what a caller gets when none is running. |
| Transfer and escalation | What an escalation phrase queues on a live call, why the transfer capability is asked of the provider rather than assumed, and what the live carrier does not carry. |
| Turn detection and end of speech | Deciding that the caller has finished speaking: the model's own detection, the host semantic path with dynamic endpointing, and how to choose between them. |
| Voice profiles | Named bundles of voice settings: where one can be attached, the six-step resolution order that decides which wins, and what is recorded on the call. |
| What a call costs | Why a voice call is metered by modality rather than by a total token count, the reporting field that never existed, and what a call reporting no tokens is charged. |
| What a setting cannot change | Findings the call review counts but does not score, why they come with no control to turn, and the two behaviours proven unreachable by prompting. |
| Who ended the call | The six values of hangup_by, why every non-caller ending once read as 'agent', and how to tell an ended call from a dropped one. |
| Your business number in Connect | What a phone number becomes once a workspace claims it: a channel_routes line that carries the provider, the permissions, the hours and the routing. |
Questions#
Do I have to choose an engine before I can use the phone channel?
No. A line works on the turn-based carrier path without any extra configuration. The realtime engine is something a workspace opts into by setting voice.engine = "realtime", and it needs the number linked at the carrier to an inbound trunk, which is console work at the provider rather than a switch in Connect.
If a call goes wrong, where do I look first?
Put the carrier's own call log next to the calls list for the same period. A call the carrier records as completed with no matching row in Connect is a bug every time, and it narrows the problem to routing or verification rather than to the conversation.
Is the phone channel the same for the Owner and for a customer?
Yes. One implementation serves both, with the customer session reaching it through the tenant facade. The only asymmetry is commercial: a customer's usage is bounded by their plan's allowances.