> For the complete documentation index, see [llms.txt](https://docs.concurrence.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.concurrence.com/platform-overview/how-a-call-works.md).

# How a Call Works

Follow one call end to end: channel, service and voice family, Context Graph state, tools and records, safety layers, transfer, run record, and evals.

This page follows one phone call from the first ring to the evidence a team reviews afterward. Each step names the part of Concurrence that acts, what it decides, and the page that explains it in depth. Read it first if you want one mental model before the detailed chapters.

The example is a patient calling a clinic line to move an appointment. Text conversations follow the same path apart from the voice steps, and the differences are noted where they matter.

<figure><img src="https://3635224444-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FvcLyiHRcwv7g83p6vxAd%2Fuploads%2Fgit-blob-ab877eab963cc38621ccc481f182d3930340fb1b%2Fhow-a-call-works.svg?alt=media" alt="A channel starts the call and the service sets its runtime. A Context Graph state guides each turn, tools read and write records after caller verification, and safety layers act on replies. A transfer or an operator can take the call, the run records what ran, and evals and simulations test the result."><figcaption><p>One call, eight steps. Each step links to its owning page below.</p></figcaption></figure>

## 1. A Channel Starts the Conversation

A conversation reaches Concurrence through a channel: a phone call to a provisioned number, an SMS or other managed message, a text conversation from your web application, or a voice session from your own app. Each channel has its own identity, consent, delivery, and lifecycle rules, so a working text client says nothing about SMS delivery or phone routing.

For a phone call, the number is routed to exactly one service. A matching phone number points to a candidate patient record. It is not proof of who is speaking.

**Go deeper:** [Channels Overview](https://docs.concurrence.com/channels/conversations.md), [Phone](https://docs.concurrence.com/channels/voice.md), [Text Sessions](https://docs.concurrence.com/channels/text-sessions.md), [SMS](https://docs.concurrence.com/channels/sms.md), and [Run a Voice Session in Your App](https://docs.concurrence.com/developer-guide/guides/app-voice-session).

## 2. The Service Selects the Agent, Graph, and Voice Family

The service is the unit that runs. It binds an agent (identity and guidance), a Context Graph (the workflow), the tools the workflow can use, and the voice settings. Version sets can pin the agent and graph versions the service resolves, so a release is a deliberate change of pins.

For voice, the service chooses one of five voice families with `voice_config.session_provider`:

| Family                | How it runs a call                                                                                                                                                                |
| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `concurrence` cascade | Separate speech recognition, Concurrence reasoning, and speech generation, with multi-state graphs, warm transfer, outbound calls, and operator takeover on supported phone calls |
| `gpt_realtime`        | A speech-to-speech model on one action state or a graph of 2 to 12 action states                                                                                                  |
| `eleven_realtime`     | A speech-to-speech session in an ElevenLabs voice on exactly one action state                                                                                                     |
| `gpt_live`            | Realtime speech that delegates tool requests to Concurrence reasoning on multi-state graphs, in US workspaces                                                                     |
| `grok_voice`          | A speech-to-speech session in a built-in Grok voice on exactly one action state                                                                                                   |

The families share the service contract, but their channels, regions, graph support, transfers, and safety coverage differ. Check the family before you rely on a control.

**Go deeper:** [Core Concepts](https://docs.concurrence.com/platform-overview/core-concepts.md), [Voice Families](https://docs.concurrence.com/channels/voice.md#voice-families), [Choosing a Realtime Voice Family](https://docs.concurrence.com/developer-guide/platform-api/workspaces/voice-configuration#choosing-a-realtime-voice-family), and [Voice Families as Swappable Runtimes](https://docs.concurrence.com/design/voice-families.md).

## 3. A Context Graph State Guides Each Turn

The call opens with an AI and recording notice, then the agent works from the current Context Graph state. A state carries an objective, guidance, boundary constraints, the tools it may call, and the exits that move the conversation on. Context Graphs accept action, decision, annotation, and data-collection states.

The graph makes the intended workflow reviewable. It does not make model output deterministic: on every runtime, the model can still miss an exit or misread a request.

**Go deeper:** [Context Graphs](https://docs.concurrence.com/agent/context-graphs.md), [Reasoning Engine](https://docs.concurrence.com/agent/reasoning-engine.md), and [Audio Pipeline](https://docs.concurrence.com/channels/voice/audio-pipeline.md).

## 4. Tools Read and Write Through Checked Paths

To move the appointment, the agent needs the patient's record and the scheduling system.

* **Caller verification.** A caller matched by phone number starts unverified, and built-in record reads return `verification_required`. The record loads only after the caller's full name and date of birth match exactly one record through `world_confirm_patient_identity`. After that, built-in record reads return only the caller's own record or a household member's that names them.
* **World model reads.** The world model supplies source-linked context. Its projections are asynchronous, so a write that was just accepted may not be queryable yet.
* **Integration actions.** The appointment change goes through a configured integration endpoint. The endpoint's own result is the evidence of what the destination accepted. A write with no settling answer reports `"outcome": "unknown"` and is not sent again in that conversation.
* **Context bindings.** A value your application supplies at conversation start can fill a tool parameter directly, so the model doesn't supply that value.

**Go deeper:** [Clinical Tools](https://docs.concurrence.com/agent/clinical-tools.md), [Platform Functions](https://docs.concurrence.com/agent/platform-functions.md), [World Model](https://docs.concurrence.com/data/world-model.md), [Caller Verification](https://docs.concurrence.com/developer-guide/platform-api/conversations/voice-agent#caller-verification), and [Verified Actions Over the World Model](https://docs.concurrence.com/design/verified-actions.md).

## 5. Safety Layers Act Around the Model

Several controls run beside the model rather than inside its prompt. Which ones apply depends on the runtime and channel:

* **Emergency recognition.** On `gpt_realtime`, a caller line recognized as describing a medical emergency or self-harm, in English or Spanish, cuts off the agent's reply, and the model speaks an authored emergency script first. GPT-Live and Grok Voice play their emergency scripts from prerecorded audio. On platform-managed voice, the agent's own reply plays.
* **Emergency calls stay open.** Once a caller describes a medical emergency or self-harm, the agent doesn't end the call on platform-managed voice or `gpt_realtime`, unless a `gpt_realtime` service sets `medical_emergency_ending: end_after_script` and the emergency is medical and described in English.
* **Crisis lines.** The agent's instructions carry the deployment region's crisis resource. On text, a message that matches the self-harm patterns gets an authored script with the crisis line where one exists and the emergency number.
* **Reply checks.** On both voice runtimes, a pattern check and a model check review each reply, and a stopped reply is cut off and corrected. A claim that a booking or message is done needs a matching write that succeeded. On text, the pattern check only logs.
* **Safe exit.** When a platform-managed or `gpt_realtime` call can't set up or a turn gets no reply, the agent plays fixed audio and transfers to the service's `fallback_to` or fixed forwarding number, or closes the call.

Recognition covers a limited set of phrasings and can miss others. The crisis rule covers suicidal thoughts, self-harm, and an overdose. Any other missed emergency rests on the agent's own instructions.

**Go deeper:** [Runtime Safety](https://docs.concurrence.com/operations-and-safety/runtime-safety.md), [Reply Checks](https://docs.concurrence.com/operations-and-safety/runtime-safety.md#reply-checks), and [Safety Layers That Don't Depend on the Model](https://docs.concurrence.com/design/safety-layers.md).

## 6. A Person Can Take the Call

When the caller asks for a person, the agent is told to transfer when it can, to take a message only through a tool that records one, and otherwise to explain how to reach the team.

* **Transfer.** The service's `voice_config.forwarding` block enables `forward_call` and selects warm or cold transfer. In dynamic mode, the agent can dial only numbers in `approved_destinations`, and each number must also be on the line's forwarding allowlist. Public emergency and N11 short codes are refused as transfer destinations. A transfer that can't connect returns the caller to the agent.
* **Operator takeover.** On supported platform-managed phone calls, an operator can join by phone, listen, take over, and hand the call back. Text runs support takeover through the operator APIs, a beta feature a workspace must be enabled for. The realtime families don't support operator takeover.

**Go deeper:** [Operators and Escalation](https://docs.concurrence.com/operations-and-safety/operators.md) and [Call Forwarding](https://docs.concurrence.com/developer-guide/platform-api/conversations/voice-agent#call-forwarding).

## 7. The Run Records What Ran

Each conversation appears as a run in the unified Runs inventory. The run reports `session_provider`, the runtime that handled it, and a `manifest` with the agent and graph versions, the version set, and the models the first session started with. Depending on the runtime and on successful persistence, the record holds turns with timing, tool calls with inputs and outputs, state transitions, and escalation events. Recordings and trace analysis are separate artifacts with their own availability.

A missing artifact is a gap to investigate, not proof that nothing happened.

**Go deeper:** [Runs](https://docs.concurrence.com/developer-guide/platform-api/conversations/runs), [Call Recordings](https://docs.concurrence.com/channels/voice/recordings.md), [Call Intelligence](https://docs.concurrence.com/intelligence-and-analytics/intelligence/call-intelligence.md), and [Call Trace Analysis](https://docs.concurrence.com/developer-guide/platform-api/safety/call-trace-analysis).

## 8. Evals and Simulations Test the Result

Before a release, simulations run the same reasoning path against synthetic callers. Tools run in simulation mode and return a `dry_run` result, except that a launch can run chosen reads for real or return configured results. Writes never run for real. After a release, production evals can score completed conversations against the workspace's active definitions on a best-effort basis.

Neither result moves a release on its own. A person reviews the evidence and changes the version-set pin.

**Go deeper:** [Testing Overview](https://docs.concurrence.com/testing/testing.md), [Simulations](https://docs.concurrence.com/testing/testing/simulations.md), [Deployment Model](https://docs.concurrence.com/platform-overview/deployment-model.md), and [Provable Releases](https://docs.concurrence.com/design/provable-releases.md).

## Next

Continue with [What Concurrence Does](https://docs.concurrence.com/platform-overview/what-amigo-does.md) for product scope, or [How It Works](https://docs.concurrence.com/platform-overview/how-it-works.md) for the same appointment change traced through data, configuration, and evidence boundaries. To build one yourself, follow the [Learn by Building](https://docs.concurrence.com/developer-guide/guides#implementation-path) path in the Developer Guide.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.concurrence.com/platform-overview/how-a-call-works.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
