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

# Interruptions

> Decide whether the caller can talk over a step: the Interruptions menu (Normal, Uninterruptible, Uninterruptible turn, Allow skip), the Verbatim threshold, and the call.step variables that tell a later step whether the last line was actually heard.

## What are Interruptions?

On a phone call, people talk over each other. By default the assistant lets the caller cut in: it protects the first few seconds of each line, then stops speaking if the caller starts talking and responds to what they said. That suits normal conversation, but some lines must be heard in full (an AI or recording disclosure, a consent statement, a regulated disclaimer). Other lines are better dropped altogether if the caller has already moved on.

The **Interruptions** setting controls this for each step. You'll find it on the step's menu:

**Scripts → *(your script)* → Script tab → step menu → Interruptions**

The menu explains itself on screen: *"Whether the caller can talk over this step. Normal protects only the first few seconds. Use Uninterruptible for anything that must be heard in full, such as an AI or recording disclosure. Uninterruptible turn also ignores anything the caller says until this step has finished (it is still recorded in the transcript) — use for steps that must run to completion, such as lookups and hand-offs. Allow skip is the opposite: the caller may cut the line before it starts and the line is simply dropped"*.

***

## The four modes

| Mode                     | What the caller can do                                                                                                                                                                                              | Use it for                                                                                                                        |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **Normal** (default)     | Talk over the line after the first few seconds. The assistant stops and responds to them.                                                                                                                           | Ordinary conversation, which covers most steps.                                                                                   |
| **Uninterruptible**      | Nothing cuts the line off. Anything they say while it plays is answered once the line has finished.                                                                                                                 | Disclosures, consent wording and anything else that must be delivered whole.                                                      |
| **Uninterruptible turn** | Nothing they say during the step's whole turn is answered or acted on. That covers the line, the assistant's thinking time and any silent tool steps that follow. Their words are still recorded in the transcript. | Steps that must run to completion without being derailed, such as a lookup followed by a transfer.                                |
| **Allow skip**           | Speak before the line starts, and the line is dropped.                                                                                                                                                              | Optional lines that only make sense if the caller hasn't already started talking, such as a filler or a "while I have you" aside. |

A step set to anything other than **Normal** shows a badge (**Uninterruptible**, **Uninterruptible turn** or **Allow skip**) so you can see the setting at a glance.

### Normal

The default for every step. The start of each line is protected for a few seconds so a cough or a quick "yep" doesn't cut the assistant off mid-word. After that, the caller can interrupt. When they do, the assistant stops, listens, and responds. If it hadn't finished getting its point across, it works the missing information back in before moving on.

### Uninterruptible

The line plays to the end, however much the caller says during it. Nothing is lost: once the line finishes, the assistant responds to whatever the caller said.

Use it for the lines where a partial delivery is a problem. For example, on a mobile phone, line noise and the handset's own speaker can register as the caller speaking. With **Normal** that can cut the end off a disclosure. With **Uninterruptible** the disclosure is always delivered whole.

### Uninterruptible turn

This goes further than **Uninterruptible**. From the moment the step starts until its turn is over, including the time the assistant spends thinking and any silent tool steps it runs through, caller speech is recorded in the transcript but never answered or acted on. It still counts as the caller being active, so it resets the [Silence Tolerance](/conversation-dynamics/silence-tolerance) timers.

Use it on steps that must finish what they started. A typical case is a line such as "Let me put you through now" followed by a lookup and a transfer, where a stray "okay" from the caller should not pull the call off course.

It has little effect on a step that asks a question. The guard lifts as soon as the assistant stops and listens for the caller's answer, so there is nothing left to protect. Keep it for one-way lines.

### Allow skip

The opposite of **Uninterruptible**. If the caller starts speaking before the line has begun to play, the line is simply dropped. It is not retried and no replacement is generated. The caller's words are then handled normally, as if the line had never been queued.

The on-screen help puts it as: *"Caller speech before this line starts skips it: no retry, no generated fallback; the caller's turn is routed normally."*

Once the line has started playing, **Allow skip** behaves like **Normal**. It only matters in the short gap before the audio begins, and it only does anything on a step that has a script.

***

## Verbatim threshold

Below the four modes, the same menu has a **Verbatim threshold** box. It decides when a line that started but was cut off still counts as said. The help text reads: *"A line that started and was cut counts as said once this percentage was spoken. 0: any start counts. 100: only the full line."*

* It takes a whole number from **0** to **100**. Leave it blank to use the default of **80**.
* A line cut off after reaching the threshold counts as delivered. The assistant carries on in its own words rather than reading the rest of a half-spoken line again.
* A line cut off before the threshold does not count as said. Later steps can see this (see below), and if the step runs again the line is said again word for word. A line the caller cut before any audio played is re-sent at most three times; after that the assistant says it in its own words. (On an **Allow skip** step it is dropped instead.)
* A step with a threshold set shows a **Verbatim NN%** badge.

Raise the threshold for lines where the ending matters (a disclosure whose last clause carries the consent question, for example). Lower it for long lines where the first half does the real work.

The spoken fraction counts words as they are spoken, so a number written as "18 to 29" in the script is measured as "eighteen to twenty-nine".

***

## Was the last line heard? The `call.step` variables

Every step with a script records what happened to its line in four read-only variables. A later step, condition or [Code Step](/tools/code-step/overview) can read them to avoid acting on a line the caller never heard (for example, not counting a consent statement as given when the caller cut it off).

| Variable                                    | Type   | Example   | What it tells you                                                                                                                                   |
| ------------------------------------------- | ------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{{call.step.last_preaudio_skipped}}`       | string | `"false"` | `"true"` when the line was dropped before any audio played (an **Allow skip** step the caller spoke over). `"false"` otherwise.                     |
| `{{call.step.last_script_skipped}}`         | string | `"true"`  | `"true"` when the line started but was cut before it reached that step's **Verbatim threshold**, so it does not count as said. `"false"` otherwise. |
| `{{call.step.last_script_spoken_fraction}}` | number | `0.62`    | How much of the line was spoken, from `0` to `1`. A line spoken in full reads `1`.                                                                  |
| `{{call.step.last_script_step}}`            | string | `"0/12"`  | Which step the other three describe, as `<flow>/<step>`.                                                                                            |

Things to know when reading them:

* **They describe the most recent scripted step anywhere in the call.** Check `{{call.step.last_script_step}}` first, so you don't act on a flag left behind by some other step.
* **The flags are the text `"true"` or `"false"`, not booleans.** Compare against `"true"` explicitly. In a Code Step, `if {{call.step.last_script_skipped}}:` is always true because `"false"` is a non-empty string.
* **They are written for every scripted step automatically.** You don't need to change the step's Interruptions setting to read them.
* **They are read-only.** Writing to them has no effect.

```python theme={null}
def run():
    if {{call.step.last_script_step}} != "0/12":
        return False
    return {{call.step.last_script_skipped}} == "true" or {{call.step.last_preaudio_skipped}} == "true"
```

Route the true result back to the disclosure step so it is read again in full, and the otherwise result onward.

***

## Offers from Live Handoff and Intent Pathways

When the assistant offers to connect the caller to a person through [Live Handoff](/scripts/live-handoff), or to take them somewhere else through an [Intent Pathway](/scripts/intent-pathways), the offer is always spoken in full and cannot be talked over. The caller's answer is listened for once the offer has finished. Anything the caller says over the top of the offer is ignored, so a caller who says "yes" too early has to say it again. This is built in and does not depend on the step's Interruptions setting.

***

## Best Practices

1. **Leave most steps on Normal.** Being able to interrupt is what makes the assistant feel like a conversation.
2. **Make disclosures Uninterruptible.** Anything with a legal or consent purpose should be delivered whole.
3. **Use Uninterruptible turn on one-way steps only.** It is for "doing something now" lines, not questions.
4. **Use Allow skip for optional lines.** If the caller is already talking, a filler line adds nothing.
5. **Check the `call.step` flags before counting a line as heard.** Especially where a later step relies on the caller having heard it.

***

## Next Steps

* [Steps Overview](/flows/steps) — every setting on the step menu
* [Voice Steps](/flows/steps-voice) — writing lines and how interrupts affect them
* [Fast Response](/conversation-dynamics/fast-response) — whether a step waits for a reply
* [Assistant Behaviour](/conversation-dynamics/assistant-behaviour) — what the assistant can and can't know about being interrupted