> ## Documentation Index
> Fetch the complete documentation index at: https://docs.firetone.com.au/llms.txt
> Use this file to discover all available pages before exploring further.

# Virtual agents

> An AI that answers the phone, holds the conversation and can act.

export const Unverified = ({what, detail}) => <Warning>
    <strong>Not yet verified on a live call.</strong> {what} is built and covered
    by tests, but {detail} FireTone's engineering tracker records this as an open
    check rather than a passing one. Treat what follows as the design, and expect
    rough edges the first time you run it.
  </Warning>;

A **virtual agent profile** describes an AI that answers calls: which provider
and model, what voice, what it is told, and how it presents itself.

Profiles live in **Settings → AI**, beside the choice of which provider
answers. **New profile** and **Edit** open the profile on a page of its own
rather than in a dialog, because there is too much on it for one. There is no
sidebar entry for profiles; a virtual agent that holds an extension also
appears in [Teams & agents](/tenant/phone-system/teams-and-agents) like any
other agent.

## What a profile carries

|                                      |                                                                                                                                                                                           |
| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Provider and model**               | OpenAI, Google or Alibaba                                                                                                                                                                 |
| **Voice**                            | How it sounds                                                                                                                                                                             |
| **Display name, presentation, tone** | Who it says it is, and how it speaks                                                                                                                                                      |
| **Opening line**                     | Said word for word at answer, so it is followed rather than paraphrased                                                                                                                   |
| **Language**                         | A starting language; it follows a caller who prefers another                                                                                                                              |
| **Role**                             | Its purpose, goal, procedure and limits. See [below](#its-role-and-the-rules-it-keeps)                                                                                                    |
| **When it doesn't know**             | Who it offers to connect the caller to, and who calls back                                                                                                                                |
| **What it can do**                   | The actions it may take                                                                                                                                                                   |
| **Additional instructions**          | Anything else, added after the role and the rules                                                                                                                                         |
| **Ring before answering**            | How long the caller hears ringing. The agent gets ready during it, so the greeting is heard as soon as the call is answered                                                               |
| **Reply speed**                      | How long it waits after the caller stops talking before answering: **Quick** (the default) suits most calls; **Patient** suits callers who read out long numbers and pause between groups |
| **Line audio**                       | Leave on *Match the provider*. **8 kHz** suits phone lines: with OpenAI the call's G.711 is used as it is, with no resampling. **16 kHz** suits HD-voice handsets and the webphone        |

## Its role, and the rules it keeps

An agent is told what it is for, in this order:

1. **Who it works for**: your organisation, and only yours, with **About the
   business** in a paragraph.
2. **Its role**: the **Purpose** (Sales, Support, Reception, Bookings, Accounts)
   and the **Goal of every call**, e.g. *book a demo*.
3. **The procedure** it follows: your SOP, step by step. Choosing a purpose
   fills in a starting goal and procedure while those are empty; edit them to
   match how you work.
4. **The rules.** These are always there, and nothing a caller says, and
   nothing in *Additional instructions*, changes them:
   * Answer only from your knowledge base and what the caller says, never
     from general knowledge of products, prices or the market.
   * **Never mention, name, compare with or recommend another company,
     product or website.** If the caller brings one up, the agent says it can
     only help with your organisation and brings the call back to that.
   * When the answer is not in your knowledge, say so plainly, and never
     guess a price, date or policy.
   * Stay in its role, and decline anything unrelated.
5. **Also never**: your own limits (discounts, legal advice, other branches).
6. How it speaks, what it knows, then **Additional instructions** (what used to
   be the system prompt: existing profiles keep theirs here).

### When it doesn't know

* **Offer a person**: it offers to connect the caller to the queue or
  extension you choose. If that fails, or the caller would rather not wait, it
  arranges a callback.
* **Arrange a callback**: it confirms the caller's name, the number to call
  and their question, and raises a ticket assigned to the person in
  **Callback from**. The caller is told who will call and given the ticket
  reference. If that person signs in to the panel, they are also emailed the
  number, the question and a link to the ticket.

An agent always has **End the call** and **Arrange a callback**, and has
**Transfer to a person** whenever a transfer target is set. It is never told
to use an action it does not have.

## Try it before a caller does

Open a saved profile and press **Try it**. You type as the caller and the agent
answers in text, with the same role, procedure, rules and knowledge it would
have on a call. It uses a text model from the profile's provider (GPT-4o mini,
Gemini 2.5 Flash or Qwen Plus) on your organisation's own key, falling back to
your OpenAI key. It does not use the realtime voice model.

* Its **knowledge base searches are real**: each answer shows what it searched
  for and which articles it found.
* **Transfers, callbacks and other actions are not carried out.** They are
  shown as what it *would* do.
* **Show what the agent is told** displays the full instructions.

Ask it about a competitor, and ask it something your knowledge base does not
cover. It should decline the first, and for the second say it doesn't have
that information and offer a person or a callback. Try it uses the saved
profile, so save before trying a change.

## Creating one

**Extensions → New extension → An AI agent**, then choose the profile that
should answer. That gives the agent a number: dialling it opens a media stream
to the model instead of ringing a device.

Nothing registers against that extension, so it has no handset settings and no
Desk sign-in. The SIP password still exists — it is an ordinary extension —
but nothing uses it unless you later point the number at a person.

<Note>
  An organisation with no profiles yet cannot create one: a profile is what
  gives the agent its provider, model, voice and opening line. Make one under
  **Settings → Virtual agent profiles** first.
</Note>

## How a caller reaches one

Three ways, and they are the same agent:

* **By dialling its extension**, as above.
* Through a **virtual agent** node in a workflow, which a process or a number
  points at. The node ends the flow: after the AI, the call is the AI's.
* From a **campaign**, which does not need an extension at all.

## What it can do

An agent's skills are the actions its profile enables, intersected with what
your organisation has switched on. Among them:

* **Transfer to a person** — to an extension or a queue. If nobody is reachable
  and that extension takes messages, it records one instead and says so, rather
  than reporting a failed transfer.
* **Bring somebody in** — a third party, with the caller still on the line.
* **Remember** something about the customer, and **learn** something about the
  job.
* Whatever apps you have enabled: raising a ticket, booking an appointment.

## What it leaves behind

Every call produces a conversation record: the transcript turn by turn (both
sides: with OpenAI the caller's words are transcribed by the provider), every
action it took with its arguments and result, the tokens it used, and **the
prompt it was given, verbatim**.

That last one is why *"why did it say that?"* is answerable. The prompt is built
at runtime from the profile's role and rules, the customer, past summaries, open
tickets and memory, none of which can be reconstructed after they change, and
it is stored exactly as the model received it.

### The post-call review

When an agent's call ends, its transcript is checked, and anything found is
flagged on the conversation:

* **competitor**: the agent named one of the profile's **Competitors**, as a
  whole word in any case. The caller naming one is not flagged.
* **no KB search**: the knowledge base was too large to give the agent whole,
  and it answered the caller without searching it once.

In **Conversations**, flagged calls carry a red badge, the **Review** filter
lists them, and the transcript highlights the turn. The server also logs
`ai agent mentioned a competitor` as a warning.

## Answering for a person

A profile can answer a person's calls **before** their phone rings: the
**Assistant, then extension** step in a call flow, or "An assistant, then a
person" in the number wizard. The assistant greets the caller, learns who
they are and what they want, answers anything simple it can from the
knowledge base, and hands over. Then the person is rung -- and three things
are true of that ring:

* **Their phone shows the caller's own number**, not the assistant's and not
  the switch's. The assistant was talking on the caller's own line, and the
  person is rung from that same line.
* **They hear a whisper first** -- "Jess Morgan, about invoice 4821" -- before
  the two are joined. The caller hears ringing meanwhile. Turn it off on the
  step if the person would rather not.
* **A note lands on their phone** as they answer: the caller's name and
  reason as the title, the assistant's summary as the body, coloured by how
  urgent the caller made it sound. It is listed on the extension's page with
  every other note the phone was sent.

A colleague reaching the step is put straight through unless the step says
*screen colleagues too*: they know who they want. If the person does not pick
up, the step's `no_answer` outlet decides -- a queue, a message, a callback --
or, unwired, the extension's own voicemail takes the call. If the assistant
cannot run at all, the person's phone rings anyway, unscreened: the assistant
is never the reason a phone stays silent.

## Handing over to a person

When the AI transfers a caller to an agent, it writes a **summary** — why they
called, what was collected, what was promised — and the agent sees it before
they speak. See [what the AI already asked them](/agent/before-you-picked-up).

<Unverified what="Calls answered by a real AI provider, and the handover summary" detail="the credential storage and the call path are both built, but no call has yet run against a live OpenAI, Google or Alibaba key on this installation." />
