# Live Conversations (/docs/agents/live-conversations)

> For the complete documentation index, see [llms.txt](https://docs.tandemcx.ai/llms.txt). Any page on this site can be fetched as Markdown by appending `.md` to its URL.

The **Supervisor** section shows every agent conversation your organization has right now,
across both channels: phone calls and website chats. For each one you can see which agent is
handling it, who is on the other end, and how long it has been going — and you can open any of
them and read the conversation as it happens.

It updates as conversations start, move, and end. You don't refresh it, and you don't pick a
date range. The board is meant to be left open on a second screen.

If your organization has no agents yet, the empty board shows a **Create Agent** button that
takes you to the Agents page to set one up.

## What a row tells you

The live conversations are listed in the **left-hand navigation sidebar** — they _are_ the
Supervisor sidebar, so they are there whenever the section is, and the page itself shows the
transcripts you have opened. Each row shows:

| Field         | What it means                                                                                                                                                                                                                                                                                |
| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Icon**      | The channel: a handset for a phone call, a speech bubble for a website chat.                                                                                                                                                                                                                 |
| **Agent**     | The name of the agent handling the conversation. A dash means the agent's configuration couldn't be read — the conversation is unaffected.                                                                                                                                                   |
| **Party**     | For a call, the caller's number. For a chat, the name of the chat widget the visitor is using — which site they came from. A dash for either means it couldn't be determined; see below.                                                                                                     |
| **Duration**  | For a call, how long it has been up. For a chat, how long since the last message. Either way it ticks in place; hover it to see which clock you are looking at.                                                                                                                              |
| **Status**    | **Live** / **Connecting** for calls, **Active** / **Idle** for chats. See below.                                                                                                                                                                                                             |
| **Sentiment** | Not a field of its own — a second badge that appears _beside_ **Status** when there is something to say: **Escalating** when they are asking to leave the agent, or **Negative** / **Positive** when their words lean that way. Nothing appears for an ordinary conversation. Both channels. |

Above the list, a **search** box narrows it by agent name, phone number, or widget name, and the
button beside it holds three more controls:

- **Sort by** — **Longest** (the default), **Newest**, or **Agent A-Z**. Longest leads because a
  conversation that has gone unusually long without moving is normally the reason to be here.
- **Agent** — show only one agent's conversations. Only agents that currently have one are
  offered, so the list empties out as they finish.
- **Supervision** — show conversations by who has them. See
  [Monitoring and viewing a conversation](#monitoring-and-viewing-a-conversation).

The button is highlighted whenever any of them is off its default, and hovering it says how the
list is currently sorted and filtered. Under the search box, a count reads **2 active · 14 idle**
— or `3 of 12` while search or a filter is hiding rows, so a narrowed list is never
mistaken for a quiet queue.

## Why chats behave differently from calls

A **phone call** is a connection that is either up or not. Its row exists for exactly as long
as the call, and vanishes the moment the caller hangs up.

A **website chat** has no equivalent. A visitor sends a message, gets an answer, then reads it
— and may reply in ten seconds, in ten minutes, or never. There is no moment at which they
"hang up". So a chat conversation stays on this board while it is **still going**. It leaves in
two cases:

- It **ended** — your agent finished it, or it reached its message limit. It leaves the board
  straight away.
- Nothing has been said for **30 minutes**. It leaves the board, because at that point the
  visitor has closed the tab.

Leaving the board is not the same as being over. A visitor can still pick a conversation up for
**24 hours from their last message**, and if they reply it comes straight back to the board as
**Active** — it is live again, and you should see it. After 24 hours, replying starts a new
conversation instead.

Three different windows, answering three different questions:

| Window     | Question                                                                |
| ---------- | ----------------------------------------------------------------------- |
| 30 minutes | Is anyone there right now? — whether it is **on this board**            |
| 24 hours   | Can the visitor pick this up? — whether replying **continues** it       |
| 90 days    | Can the visitor still read it? — how long it stays in **their history** |

The first is deliberately much shorter than the others: a board showing every conversation your
agent could still answer would be mostly conversations nobody is having.

That's also why a chat's Duration counts from its last message rather than from when it opened.
A visitor who chatted this morning and left the tab open would otherwise show up as a
nineteen-hour conversation, which is true and tells you nothing. It is also what the list sorts
on, so a chat nobody has touched since breakfast never sits above a call that is ringing now.

## Reading a conversation as it happens

Click a conversation in the sidebar to open its transcript on the page. It fills in with
everything said so far and then adds each message as it arrives — the caller's or visitor's
words on one side, the agent's on the other. Picking one from another part of the app takes you
to the Supervisor page on the way.

Both channels open the same way. A **call** streams as the words are spoken; a **chat** updates
as messages are sent, which for an idle conversation means it sits still until the visitor comes
back — the transcript you are looking at is the whole conversation, not a snapshot of it.

**You can open several at once.** Click more rows and they sit side by side, which is the point:
this page is for watching, and comparing two conversations is usually more useful than staring
at one. Up to six can be open together. Once six are open the remaining rows are unavailable
until you close one — click an open row again, or the **✕** on its column.

Scrolling up in a transcript stops it from jumping to each new turn, so you can read back
without the view jumping under you. **Jump to Latest** returns you to the bottom and resumes
following.

Collapsing the navigation sidebar hides the conversation list, so anything you have open stays
open and the transcripts get the full width. A single **Live Conversations** button stays in the
collapsed rail, so the page is still one click away.

**Every message carries the time it was recorded**, under the message itself, with seconds, so
you can see how long the agent took to answer, not just what it said. Hover a message for its
full date and time, which is what you want on a chat that has been open since yesterday.

On a call the time is when the platform received the turn from the agent, so it trails the moment
the caller actually spoke by however long the agent took to think. On a chat it is when each
message was recorded, so a visitor's message and the reply to it carry the times they landed.

A few things to know about a transcript before you rely on it:

- **A tool call appears in the transcript.** Looking something up, calling out to another system,
  capturing keypad digits — each one gets a row of its own, where it happened, carrying how it
  turned out and the arguments the agent sent. Admins can expand a row to see the request and
  response behind it. See [What the agent did](#what-the-agent-did).
- **A call's transcript is not the recording, and it is not a legal record.** Speech recognition
  makes mistakes, particularly on names, numbers, and accents. Read it as a good indication of
  what is being said, not as a verbatim quote. A chat is what was typed.
- **A call's transcript is not saved here.** Closing the column, leaving the page, or reloading
  discards it; for one you can come back to, see the agent's **Recent Calls** after the call
  finishes. A chat's is a different matter. It stays with the conversation, so re-opening it
  shows the same messages again for as long as the conversation is on the board.
- **When a call ends** its row leaves the list, but its transcript stays on screen and is marked
  **Ended** so you can finish reading. Close it when you're done. A chat your agent finished is
  marked **Ended** the same way. A chat that has only gone quiet is marked **Idle** instead: it
  hasn't ended, and the visitor may still reply.
- **A call may show "Wrapping Up" for a few seconds after the caller hangs up.** If the agent has
  caller memory switched on, it writes down what it learned about the caller once the call is over.
  The column reports that as it happens and then says how it went — see
  [After the call: caller memory](#after-the-call-caller-memory).
- **On a very long conversation the transcript stops growing.** There is a size limit; once it
  is reached the column says so, and the conversation carries on unaffected.

## Monitoring and viewing a conversation

One supervisor at a time monitors a conversation. Opening a transcript that nobody is monitoring
makes you its monitor, and its header shows a purple **Monitoring** badge. Anyone who opens it
while you are monitoring it is viewing it: their header shows a gray **View Only** badge, with a
line under it naming who is monitoring.

Only the supervisor monitoring a conversation can act on it: coach the agent, join, listen to the
call, take it over, act on a held chat reply, or dismiss an alert. Someone viewing it can read the
transcript, the coaching notes, and the alerts, and nothing else.

You stop monitoring a conversation when you close its transcript or leave the Supervisor page, and
the same goes for viewing one. Monitoring does not pass to the next person by itself. A supervisor
still viewing the conversation sees **Nobody is monitoring this conversation** and a **Monitor**
button, so taking it on is their choice, and a dropped connection reconnects them as a viewer. To
step back while keeping a transcript open, use the button with a crossed-out eye in its header
(**Stop monitoring — keep viewing, read-only** on hover).

Joining holds a conversation for longer. One you have joined stays yours until you close it out,
for up to 12 hours, whether or not its transcript is open.

In the list, conversations someone else has are grouped under **Monitored by others**, below the
rest under **Available**. Their row names that supervisor and what they are doing: **Monitoring**
in plain text, with a headphones icon while they are listening, or a **Joined** or **On call**
badge once they have joined. An eye with a number counts who else is viewing, and hovering it lists
their names. The sort and filter button's **Supervision** filter has four options: **All**,
**Unattended** (nobody is monitoring it or has joined it), **Mine**, and **Other supervisors**.

## Coaching the agent

**Coach** at the foot of a transcript opens a box for a note to the agent. The agent reads it
before its next reply and never mentions it. The customer never sees it. The note appears in the
transcript where it was written, marked **will shape the next reply** until the agent has replied
with it, then **applied to the reply below**.

To coach on something said earlier, hover a message from the agent or the customer and click the
coach icon beside it. The box opens with that message quoted above it, and the message is
outlined in the transcript. The agent gets the quote with your note, so a note such as "too
formal" reaches it with the reply you meant. Click another message to quote that one instead, or
the **×** beside the quote to send an ordinary note. A quote longer than 300 characters is
shortened.

## What the agent did

When the agent uses a tool — looking a caller up in your system, capturing keypad digits,
transferring — that call appears in the transcript as a row of its own, in the place it happened.
Collapsed, the row says what the tool was, how it turned out, and how long it took when the
platform timed it. Expand it and you get the arguments the agent sent, the tool's own name as
your configuration spells it, and, when the tool failed, the reason it gave.

A built-in tool is labelled in plain English — **Capture keypad digits**, **Transfer to an outside
number**. A tool you configured carries its own name, tidied up for reading. Either way the raw
name is in the expanded row, so a row can always be matched back to the agent's configuration.

| Outcome       | What it means                                                                  |
| ------------- | ------------------------------------------------------------------------------ |
| **Succeeded** | The tool answered, and the agent carried on with what it got back.             |
| **Failed**    | The tool answered with an error. Expand the row for the reason it gave.        |
| **Running**   | The tool has been called and hasn't answered yet. Only on a live conversation. |
| **No result** | The conversation ended before the tool answered.                               |

**No result is not a failure, and the two are kept apart deliberately.** A tool that never came
back may well have succeeded a moment after the caller hung up; nobody was left to record the
answer. Reading it as a failure would assert something no one knows. It is worth noticing on a
transfer or a payment, and unremarkable on a call the caller ended mid-sentence.

**A missing duration is normal and says nothing about the call.** Tools the agent runs inside its
own reasoning — ending the call, reading your knowledge base, handing back to a workflow — never
pass through the part of the platform that times a tool, so they carry no duration at all. Neither
does any tool on a **website chat**: a chat keeps nothing running between messages, so there is no
clock to read. The row still reports its outcome.

**Chats differ in one more way.** Tool rows appear on a chat while it is live on this board, but a
finished chat's transcript under **Recent Chats** stays text-only. Live calls, live chats, a
finished call's transcript in **Recent Calls**, and a preview call all show them.

### Request and response details

When an integration tool gets an answer from your endpoint, the row also shows the HTTP status as
a small chip beside the outcome. A tool whose endpoint answered `404` reads **Succeeded** with a
`404` chip, because the agent got an answer and carried on with it. A DNS failure or a refused
connection reads `502`, and an integration whose own request timeout fires first reads `408`. A
tool that got no answer before the tool's time limit (15 seconds by default) reads **Failed** and
has no chip.

Everyone who can open the transcript sees the chip. Admins also get tabs in the expanded row:

| Tab           | What it shows                                                                                                                                 |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| **Arguments** | What the agent sent the tool.                                                                                                                 |
| **Request**   | The method, the URL, the headers, and the body the platform built. The URL is the path alone when the integration's base URL wasn't recorded. |
| **Response**  | The status line, headers, and body your endpoint returned.                                                                                    |
| **Agent saw** | What the tool handed back to the agent, after any response extraction you set up.                                                             |

A few details about what the tabs hold:

- **Credentials are not in the Request tab.** The integration's stored credentials are added after
  the request is built, so the tab shows the request without them. A `{{secrets.*}}` value in a
  header or body shows as the token, not its value.
- **The Response tab is a scrubbed copy.** Secret values stored on the integration are removed
  from the headers and body before they are shown, so it is not a byte-for-byte record of what
  came over the wire. On a timeout it says **No response** and gives the tool's error text.
- **Bodies are cut at 64 KB.** A longer request or response body shows **Truncated at 64 KB**.
- **Tools that are not integrations** have no request or response. Their expanded row shows
  **Arguments** and, for admins, **Agent saw**.
- **Calls placed before this existed** have no **Request** or **Response** tab. Admins still see
  **Arguments** and **Agent saw**, because both come from the stored transcript.

Details are for admins because a response body is your endpoint's customer data. The check is the
administrator role, and the platform applies it before sending anything, so a non-admin's browser
never receives the request or response. See [Admin](/docs/overview/admin) for what that gate does
and does not keep out.

Details on a call or chat are kept with the transcript for 90 days and deleted with it, including
on an erasure. Details on a test result are kept for 90 days. They appear on the live board for
calls and chats, on a finished call under **Recent Calls**, in a preview call, and in the
transcript of a [test](/docs/agents/voice-agents/tests) result.

## Seeing that a visitor is typing

On a **website chat**, a bubble of moving dots appears at the bottom of the transcript while the
visitor is composing a message — the same signal they see from your agent, pointed the other way.
It disappears when their message lands.

Three things to know before you read anything into it:

- **It is chat only.** A phone call has no equivalent, and one is not missing: a caller is either
  speaking or not, and what they say arrives as a line of transcript.
- **It never appears before a visitor's first message.** A conversation reaches this page when its
  first message is answered, so there is nothing on the board to show dots against until then.
- **It goes away on its own.** A visitor who starts a sentence and then closes the tab, loses their
  connection, or walks away stops being shown as typing within a few seconds. So dots mean someone
  was typing very recently — not that a message is guaranteed to arrive.

It is also not a keystroke feed: the widget reports "still typing" every few seconds rather than
per character, and nothing about what they are writing reaches this page until they send it.

## After the call: caller memory

If the agent has caller memory switched on, the last thing it does on a call happens after the
caller has already hung up: it writes down what it learned, so the caller's next call can pick up
where this one left off. That takes a few seconds, and the column shows it rather than jumping
straight to **Ended** — a call badged **Wrapping Up** has no one on the line, but the agent has not
finished.

You will see one of these:

| What it says             | What it means                                                                    |
| ------------------------ | -------------------------------------------------------------------------------- |
| **Storing memory**       | In progress. It normally settles within a few seconds.                           |
| **Memory saved**         | Saved. The caller's next call will have it.                                      |
| **Nothing stored**       | The agent had nothing new worth recording. Normal, and not a fault.              |
| **Memory not saved**     | The write failed. This caller's next call starts without anything from this one. |
| **Memory not confirmed** | The agent never reported back. What was saved, if anything, is unknown.          |

The first three are routine and need nothing from you. **Memory not saved** and **Memory not
confirmed** are worth noting: a single one is usually a transient fault, but several across
different calls point at a problem worth raising.

A call on an agent with caller memory switched off shows none of this and goes straight to
**Ended**.

## Taking a chat over

<Callout type="info">
    **Taking a chat over is being rolled out.** If a chat tile has no **Take over** button, this
    isn't enabled for your organization yet.
</Callout>

A chat tile answered by an AI agent has a **Take over** button. Only an organization admin can use
it; for anyone else the button is disabled and says so. The button is absent on a chat that a
[workflow](/docs/agents/chat-widget#answering-with-a-workflow) is driving, since there is no agent
to take it from.

Taking over is one-way. The agent doesn't answer again in that chat, and there is no way to hand
it back. Before anything else, the visitor sees the agent say **I'm going to bring in a colleague
who can help you from here. One moment.** and then a notice reading **You're now chatting with
[name]**. See [what the visitor sees](/docs/agents/chat-widget#when-a-person-takes-over). The
name follows your organization's
[chat name settings](/docs/overview/account-admin#live-chat-takeover).

Once you hold the chat:

- A **Write to the visitor…** box appears at the foot of the tile. **Enter** sends and
  **Shift+Enter** starts a new line. Messages can be up to 4,000 characters.
- The visitor sees a typing indicator while you type.
- Anyone else watching the tile sees **Handled by [name]** where **Take over** was, and has no
  composer.
- Your messages and the notice appear in the transcript, each labelled with who said it.
- **End Chat** is in the bar at the foot of the tile. It asks how the chat ended, the same way
  ending a call does, then ends the chat and records your answer. Only the supervisor who holds
  the chat sees it.

### When the person who took a chat over leaves

If the supervisor holding a chat is no longer watching it and the visitor goes unanswered for
longer than your organization's threshold, the chat gets a
**Visitor waiting** alert. The threshold is **Flag a chat as abandoned after** on the
[Organization page](/docs/overview/account-admin#live-chat-takeover): 3 minutes unless an admin
changes it. It counts from the visitor's oldest unanswered message, or from when the current holder
took the chat, whichever is later. A holder who is still watching the chat never triggers it.

Another admin then sees **Pick up** in place of **Handled by [name]**. Picking up works like
taking over: the visitor sees a new **You're now chatting with [name]** notice, with no second
colleague line. Nothing hands the chat back to the agent.

## After a supervisor takes a call over

<Callout type="info">
    **The transcript after a take-over is being rolled out.** If a call's transcript stops when a
    supervisor takes it over, this isn't enabled for your organization yet.
</Callout>

**Join** needs your microphone, and asks for it before anything else. If your browser blocks it,
there isn't one, or another app is using it, the call stays with the agent and a message says
which. If your microphone stops during the call, a headset disconnecting say, the page switches to
another microphone if there is one and tells you. If there isn't, a message says the caller can't
hear you, with **Try Again**, and a microphone you connect is picked up by itself. Keep listening
until **Joining…** finishes: if listening stops first and the take-over still goes through, the
caller can't hear you, and a message says so.

When a supervisor takes a call over, the agent finishes the sentence it's on, for up to 4 seconds.
With [**Allow barge-in**](/docs/agents/voice-agents/voice-and-speech#allow-barge-in) on, a caller
who talks over it stops it at once, as at any other time. The agent then waits up to 10 seconds for
the caller to finish speaking, tells them a colleague is joining, and leaves. With **Allow
barge-in** on, a caller who talks over that line hears it again once they finish, so it's the last
thing they hear from the agent. What the caller says while the agent waits is in the transcript.
**Join** reads **Joining…** until that's done: usually a few seconds, and longer while the caller
is still talking, up to about 25 seconds.

After the agent leaves, the transcript carries on. A line reads
**[name] took over the call. The agent left.**, and what the caller and the supervisor say after
that follows it, each line labelled with who said it. The caller and the supervisor are
transcribed separately, so a line is never put down to the wrong person. A line appears once its
speaker finishes it, so it can trail the audio by a few seconds. The column stays live until the
call ends.

At close-out the supervisor can say why they stepped in. **Why did you step in?** offers **Agent
stuck or looping**, **Wrong or missing information**, **Caller asked for a person**, **Complaint
or escalation**, **Compliance or risk**, and **Other**. It is optional, and more than one can be
picked.

Once the call is over:

- **Caller memory** takes in what was said after the take-over, so the caller's next call knows
  that a person stepped in and how the call ended. This happens only when the agent has caller
  memory switched on.
- **Coaching** reviews the agent once the call has ended and been closed out, without waiting for
  its usual count of calls, and reads why the supervisor stepped in and what they said. See
  [Coaching](/docs/agents/coaching#what-triggers-a-review).
- **Call Logs** shows who took the call over, the close-out, and the rest of the transcript. See
  [Insights](/docs/workflows/insights-and-reporting#a-call-a-supervisor-took-over).

What was said after a take-over is kept as long as the call's own transcript: 90 days when the
agent stores transcripts, whether for [transcript
retention](/docs/agents/voice-agents/safety#transcript-retention), post-call analysis, or a wrap-up
tool, and otherwise an hour, long enough to watch the call. Erasing a caller's data erases it along
with their calls.

## Reading the status values

**Calls.** Nearly every call shows **Connecting** for a fraction of a second and then **Live**.
That's the agent starting up, and it isn't worth watching. A row that _stays_ on **Connecting**
is worth acting on: the caller is connected but hearing nothing. One such row is usually a
single unlucky call. Several at once, across different agents, point at the platform rather
than at any one agent's configuration — that's the point at which to raise it.

**Chats.** **Active** means a message landed in the last five minutes: someone is very likely
still there. **Idle** means the conversation is still open and resumable, but nothing has been
said for a while. Idle is the normal resting state of a chat, not a fault — most visitors read
an answer and leave without closing anything. A board with a dozen idle chats and no active
ones means your website was busy earlier, not that something is stuck.

Because idle chats accumulate through the day, the count beside the search box reports the two
separately. The active number is the one that tells you how busy your agents are right now.

## Reading the sentiment badge

A row can carry a second badge beside its status, saying how the person on the other end sounds.
An open transcript shows the same badge in its header. There are three:

| Badge          | What it means                                                                                                                                 |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| **Escalating** | They are pushing to get out of the automated conversation — asking for a person, repeating themselves, or, on a call, talking over the agent. |
| **Negative**   | Their words are leaning unhappy.                                                                                                              |
| **Positive**   | Their words are leaning happy.                                                                                                                |

**Most rows carry none of these, and that is the normal case.** Nothing appears for an ordinary
conversation, and nothing appears before there is anything to say — a call that has only just been
answered, or a chat whose first message is still being answered, has no badge yet. A conversation
that was already under way before this arrived may not get one at all.

**Escalating is not the same as Negative, and it is the more useful of the two.** A caller can be
perfectly polite while asking three times to be put through to a person. That reads as neutral
words and high escalation, and it is usually the conversation worth opening first. The two are
measured separately for exactly that reason. When both apply, the row shows **Escalating**.

**It reads the words, not the voice.** There is no analysis of tone, volume, or how somebody
sounds — a call is read from its transcript exactly as a chat is read from what was typed. So it
inherits the transcript's mistakes: speech recognition is imperfect, particularly on names,
numbers, and accents.

**It keeps up with the conversation rather than waiting for the end of it**, but it is not
instantaneous. A chat is re-read once each message is answered, and can take a few seconds to
reach the board after that. Read a badge as "a moment ago", not "right now".

The same badge appears on the caller's turns when you try an agent out from the agent editor, so
you can see how a wording change lands before it reaches a real caller.

Treat it as a hint about where to look, not a verdict. It is there to tell you which of fifty live
conversations to open first. It is not a measure of how a conversation was handled, and it is not
something to hold an agent to.

## When Party shows a dash

For a **call**, a dash means the call arrived with no caller id. That's normal for some carriers
and for blocked numbers.

For a **chat**, a dash means the widget the conversation started in has since been deleted. The
conversation itself is unaffected and the visitor can still continue it.

Note that chats identify the **widget**, never the visitor. A website visitor is anonymous, and
this page deliberately publishes nothing that would identify one.

## What this page is not

**Coaching and taking over a chat are being rolled out.** Where they aren't enabled for your
organization, you can't coach the agent or message the visitor from here.

**There is no history here.** A call appears when it starts and disappears when it ends; a chat
appears while it is going and goes when it ends or falls quiet. Nothing on this page is a record
you can come back to later.

To look at calls that have already finished, with transcripts and post-call analysis, use the
agent's **Recent Calls** (or **Recent Chats**), or [Insights → Call
Logs](/docs/workflows/insights-and-reporting#call-logs) for workflow-level reporting.

## "This list may be incomplete"

If a warning appears at the top of the page, part of the platform couldn't be reached when the
list was last read, so some conversations may not be shown in the sidebar. The conversations
themselves are unaffected. This is about what the page can see, not about what is working.

It normally clears on its own within a few seconds. If it persists, the count beside the list is
an undercount, so don't use it to conclude that volume has dropped.

## "Delayed Updates"

Nothing normally appears beside the conversation count; a working list shows nothing there. If a
**Delayed Updates** badge appears there, the page has lost its live connection and fallen back to
re-reading the list every few seconds. Everything still works; rows may just be a few seconds
behind. It reconnects by itself.

An open transcript has its own version of this. Its badge normally reads **Live**; if it reads
**Delayed**, that column's connection keeps dropping and messages may be missing from what you
can see. The rest of the page is unaffected, and it reconnects by itself. A column showing
**Ended** is not a fault — that call has finished.

## Who can see it

Anyone in your organization. The Supervisor section is not restricted to administrators,
because supervising conversations isn't an administrative task.

Note what that grants. Everyone who can open this page can see callers' phone numbers
**and read what callers and visitors say**, including anything they volunteer: account details,
addresses, health or financial information.

<Callout type="warn">
    There is no per-section permission today. All three roles — Owner, Admin, and Member — reach the
    same pages, so the only way to keep someone out of this one is to not invite them to the
    organization. See [Manage Users](/docs/overview/manage-users).
</Callout>

## Reading it from the API

The same data is available programmatically: a single read of the list, a stream of changes to
it, and a stream of one conversation's transcript. Each conversation carries a `channel` of
`voice` or `chat`, which is what decides the rest of its fields, and — once there is a reading —
a `sentiment` carrying the same labels the badge is drawn from. See `listLiveConversations`,
`streamLiveConversations`, and `streamLiveTranscript` in the
[Voice Agent API](/docs/api/voice-agents/live-conversations/listLiveConversations).