# Building AI-Native Contact Center Platforms

> Build a full contact center where AI and human agents share one skill queue: ACD, agent desktop, IVR flow builder, supervisor, and live wallboards.

You want a contact center where an AI agent answers first, qualifies and
verifies the caller, and then, when the call needs a person, drops that caller
into the **same skill queue** that a human agent already works. This is not a
bot bolted onto a legacy ACD. It is one queue, one routing brain, and one
wallboard. AI and human agents are interchangeable resources.

That is what you build here. FirstByte Voice ships a ready-made
Contact Center console. Agents get a call desktop. Supervisors get live
wallboards. Admins get an IVR flow builder and telephony configuration. All of
it sits on top of an Avaya-shaped ACD (skills, queues, VDN vectors). The ACD
treats an AI voice agent and a human on a softphone as two ways to service the
same queued call. There is nothing to scaffold. Sign in, and the surface works.
This page walks through the pieces and how they fit.

> **NOTE:**
> What each person sees depends on their role. **Agents** get the desktop and the
> Ready surface. **Supervisors / team leads** also get the operations wallboards
> and drill-downs. The **admin** area (flow builder, skills, trunks, numbers,
> telephony tools) is limited to the owner, admin, and developer roles.

## What you're building

  - **Skill-based ACD** — Numbers → VDN → IVR vector → skill queues. One picker distributes each
    queued call to whichever resource is free — AI or human.
  - **IVR flow builder** — A drag-and-drop vector builder: announcements, digit collection, skill
    queuing, and branch logic before a call reaches an agent.
  - **Agent desktop** — Go Ready. Take screen-popped inbound calls. Work the live call with an
    assist rail. Finish with after-call wrap-up.
  - **AI + human in one queue** — An AI agent services queued calls directly. It can hand off to the human
    queue with the same accept signal that a human uses.
  - **Supervisor tools** — A live team grid with monitor / whisper / barge to coach or rescue a call
    in progress.
  - **Live wallboards** — Per-skill queue depth, service level, ASA/AHT, occupancy, and agent state.
    Also a TV wallboard and a VDN routing Sankey.

## How the shared queue works

The routing brain is a classic ACD, modeled on Avaya's shape, with one twist:
the queue does not know the resource type.

- A **VDN** (vector directory number) maps an inbound DID to a routing program
  and a default skill.
- A **vector** is your IVR program. It is an ordered list of steps
  (`announcement`, `collect_digits`, `queue_to_skill`, `check_skill`,
  `route_to_vdn`, `goto_step`, `busy`, `disconnect`). The vector decides which
  **skill queue** a call lands in.
- A **skill queue** holds callers who wait for a matching resource. A
  **picker** chooses which agent gets the next call. It uses an Avaya-style
  algorithm: `ead_mia` (expected-agent-delay, the default), `mia`, `ucd`
  (round-robin), `loa`, `lar`, or `manual`.

An **AI agent** and a **human agent** are both resources against a skill. When
an AI agent decides that a call needs a person, it calls its `route_to_skill`
tool. The tool enqueues the caller into a human skill queue through the
control-plane ACD endpoint (`POST /api/acd/queue`). A human agent accepts the
offer through the matching accept endpoint (`POST /api/acd/accept`). That is
the **same accept signal** that the ACD uses to give any queued call to any
agent. The queue does not know or care whether AI answered the call first. The
caller keeps one `call_sid` end to end.

> **NOTE:**
> The routing data model, picker, and queue/accept endpoints are shipped. A
> **warm** handoff carries the AI's collected context (intent, verification
> result, notes) into the human's screen pop. This is the product thesis for
> regulated verticals. Routing and accept are shipped. The rich context payload
> is assembled at your application layer. You build it. It is not a turnkey
> field. See
> [AI ↔ human handoff](/modalities/voice/transport-telephony/ai-human-handoff)
> and [Handoffs](/modalities/voice/concepts/handoffs).

## Stand it up

  1. **Get calls in — trunk and numbers**
Point a SIP carrier at the platform. Register the DIDs that callers dial.
    Every workspace gets its own SIP and WebRTC endpoints, provisioned
    automatically at signup: `<workspace-id>.sip.firstbyte.fast` and
    `<workspace-id>.webrtc.firstbyte.fast`. Bring your own carrier's SBC and
    credentials, or take a managed number.

    Full walkthroughs:
    [SIP trunking](/modalities/voice/transport-telephony/sip-trunking) and
    [Number provisioning](/modalities/voice/transport-telephony/number-provisioning).
  2. **Define skills, VDNs, and vectors**
Create your **skills** (e.g. *Billing*, *Retention*, *Tier-2*). Then create
    a **VDN** per inbound line that points at a **vector**. Build the vector in
    the **vector builder** (**Admin → Vectors**): drag in an announcement,
    collect account digits, branch on a `check_skill` condition, and
    `queue_to_skill` to land the caller in the correct queue. Map each skill to
    a hotline. Then the wallboard gets its KPI target bands.

    The ACD internals — vector step kinds, picker algorithms, VDN mapping — are
    covered in [PBX / ACD](/modalities/voice/transport-telephony/pbx-acd).
  3. **Put AI agents in the queue**
Bind an AI voice agent to a number or a skill so that it answers first.
    Give the agent a `route_to_skill` telephony tool and an allowlist of skills
    that it may escalate to. When the model calls the tool, the caller is
    enqueued for a human on that skill. Build the agent itself in
    [Building voice agents](/modalities/voice/build/voice-agents). Wire the
    tool in [Tool calling](/modalities/voice/runtime/tool-calling).
  4. **Put human agents in the queue**
Human agents work the queue in two ways: a **browser softphone** (they sign
    in to the console and go Ready) or a **real SIP deskphone / softphone**
    registered as an agent endpoint. In both cases, they accept queued offers
    with the same signal. Thus the picker treats them uniformly. The desktop
    walkthrough is below. SIP-phone endpoints are covered in
    [PBX / ACD](/modalities/voice/transport-telephony/pbx-acd).
  5. **Watch it live**
Open the **wallboard** and the **VDN flow** to see queues fill and calls
    route in real time. Give team leads the **Supervisor** grid. All are
    covered below and in
    [Dashboards](/modalities/voice/observability/dashboards).

## Sign in as an agent

  1. **Open the sign-in page**
Go to your workspace console (`agent.firstbyte.fast`). You land on **Sign in
    to your queue**.
  2. **Authenticate**
Continue with **Okta**, **Microsoft**, or **Google** if your team uses SSO.
    Or sign in with your **work email** and password. Complete the human-check
    if one shows. Then press **Sign in**.
    > **TIP:**
> The console does not self-register agents. A team lead adds them under
>     **Admin → Agent directory**.

## Work the agent desktop

After sign-in you land on the **Ready** surface. The top bar shows your
presence chip. The center panel shows whether you are in rotation.

  1. **Go Ready**
If you are offline, the center reads *"You're offline — no calls will route
    to you."* Press **Go Ready** to enter rotation. The panel then shows how
    many agents are in rotation with you and how many callers wait.
  2. **Check your queue and stats**
The Ready surface shows live tenant-wide pressure: **In queue (all
    skills)**, **Longest wait**, and **Service level**. It also shows your own
    **Skills assigned** and today's **AHT**, **Calls**, **ACW avg**, and
    **RONA** (missed offers). Your **Last 5 calls** list sits at the bottom.
  3. **Set an Aux status when you step away**
Click your presence chip to open **Set status**. Pick **Ready**, an **Aux**
    reason (Break, Lunch, Training, plus any that your admin configured), or
    **Sign out & go offline**.

### Answer a screen-popped inbound call

  1. **Confirm or decline the offer**
When a call routes to you, the desktop flips to an **Incoming call** card.
    The card shows the Call ID and a countdown. Press **Confirm** to take the
    call. Press **Decline** to send it back to the queue.
    > **WARNING:**
> If you let the timer run out, that counts as a **missed offer (RONA)**. Two
>     missed offers in a row move you out of rotation until you go Ready again.
  2. **Read the caller context and screen pop**
After you connect, the call ribbon shows **LIVE**, the Call ID, the
    **Trunk**, and the **Dialed** number, with a timer. If your tenant has
    screen-pop rules, a pop appears with the caller's likely intent and quick
    links — for example *Open invoice* or *Refund console*. If AI handled the
    call first, the qualification context lands here.
  3. **Use the Agent Assist rail (optional)**
The right rail can stream next-best-action, compliance, and sentiment cards
    while you talk. Insert a suggested script. Drop a suggestion in as a note.
    Or dismiss cards that are not relevant.
    > **NOTE:**
> Live Assist needs the tenant's ASR / LLM keys. Without them, the desktop
>     still works, but without the streamed suggestions.
  4. **Control the call**
The action grid gives you **Hold / Resume**, **Mute / Unmute**,
    **Transfer**, **DTMF** (a keypad to send tones that the caller hears),
    **Conference**, **Case**, and a **Supervisor** request. Write **Call
    notes** as you go. They auto-save. Press **End call** to move into
    wrap-up.

### After-call wrap-up

When you end a call, the wrap-up screen opens with your **ACW elapsed** timer
in progress.

  1. **Review the AI-drafted summary**
A summary is pre-filled from the transcript. Edit it, or press
    **Regenerate** to redraft it.
  2. **Pick a wrap-up (disposition) code — required**
Choose one code from the list. You cannot save without a disposition.
    > **NOTE:**
> If no codes appear, none are configured. An admin seeds them under
>     **Admin → Wrap-up codes → New code**.
  3. **Add tags, CSAT, and a follow-up, then save**
Add free-form **tags**. Tick **Send post-call CSAT** to send a short
    survey. Set a **Follow-up** time if the outcome needs one. Press **Save &
    Ready** to go back into rotation. Or press **Save & go Aux** to save and
    step out.

## Supervisor tools

On the **Supervisor** surface, team leads watch a live agent grid and step into
calls in progress: **monitor** (listen silently), **whisper** (coach only the
agent), **barge** (join the call), and an **agentic monitor** mode. Access is
role-gated to owner, admin, and supervisor.

> **NOTE:**
> The same presence feed drives the live team grid and the wallboard. Agents can
> raise a hand with the **Supervisor** button on the active call. The monitor /
> whisper / barge audio controls are being added to the console, and the
> Supervisor screen shows its readiness state when you open it. Until then, use
> the **Wallboard** to watch team state live. Use **All calls / Call detail** to
> review any specific call.

## Monitor the floor live

### Skill wallboard

  1. **Open the wallboard**
Go to **Supervisor → Wallboard**. It refreshes every few seconds. The top
    strip aggregates **Agents online / ready**, **In queue**, **Longest wait**,
    **Service level**, and **Calls today**, colour-coded by severity.
  2. **Read the per-skill cards**
Each skill card shows agent-state counts (ready / on call / ACW / aux),
    **in queue**, and a KPI grid: **SL%**, **ASA**, **AHT**, **Abandon**,
    **Occupancy**, and **Oldest** wait. The card compares each KPI against the
    skill's target and tints it green, amber, or red.
    > **TIP:**
> A skill tagged **unmapped** has no hotline mapped, so it has no KPI
>     targets. Map it under **Admin → Skills** to get target bands.
  3. **Filter, export, and drain AI handoffs**
Narrow to one hotline. Switch the window between **Daily / WTD / MTD**.
    Press **CSV** to export the visible rows. When AI agents escalate to a
    human, an **AI handoffs** strip appears. Press **Drain queue** to match
    those queued callbacks to available agents.

### TV wallboard

Open **Supervisor → TV wallboard** on a floor monitor. It is a chrome-free,
always-dark, oversized display. It shows a live clock, the same aggregates, and
skill cards that **auto-rotate**. Thus a long skill list cycles without a
click. It ignores your personal theme. Thus contrast stays calibrated for
projection.

### VDN call-routing flow

Go to **Supervisor → VDN flow**. The three-column Sankey shows how inbound
calls travel **Hotline → Skill → Disposition**. Ribbon width is proportional to
call volume. Click any bar to focus the chart on flows that touch that node.
Use this view to spot a hotline that funnels everything into one skill, or a
skill that ends with too many *transferred* dispositions. Switch the window and
press **CSV** to export exactly the flows that show.

## Next steps

  - **[PBX / ACD](/modalities/voice/transport-telephony/pbx-acd)** — The routing internals — VDN vectors, picker algorithms, and SIP-phone agent
    endpoints.
  - **[AI ↔ human handoff](/modalities/voice/transport-telephony/ai-human-handoff)** — How a call moves from an AI agent to a person, and what the person hears.
  - **[Building voice agents](/modalities/voice/build/voice-agents)** — Build the AI agent that answers first and escalates into the queue.
  - **[Dashboards & reports](/modalities/voice/observability/dashboards)** — Wallboards, VDN flow, call detail, and the reports behind them.
  - **[Telephony overview](/modalities/voice/transport-telephony/overview)** — Trunks, numbers, and the full inbound/outbound call lifecycle.
  - **[Building agent platforms](/modalities/voice/build/agent-platforms)** — Host many customers' voice agents on one multi-tenant platform.