Copilot
Copilot is the AI assistant built into the agent editor: the Copilot button in the toolbar, next to Test, opens its panel. Chat with it in natural language to build a flow from scratch, make a targeted edit, or restructure a whole branch of the conversation — it works out the changes and shows them to you as a Changes · N card before anything is applied. Copilot is available to the Admin and Developer roles — those with access to the agent editor. It replies in the interface language.
How Copilot works
- Copilot never changes the flow directly. Proposed changes come as a Changes · N card — a list of specific changes, such as adding a node, editing a field, or rewiring a transition. You review them and accept or reject them.
- Proposed changes are checked with the same validation rules as manual edits, so nothing broken can be accepted by mistake.
- Proposed changes are tied to the version of the flow you had open. If the flow changes before you decide, Copilot re-checks them: the card header shows flow changed, and changes that cannot be applied are marked not applicable.
- If the card has applicable changes without a decision, you can’t send Copilot a new message. A line above the input reads Accept or reject the changes before a new Copilot request — a click on it takes you to the card.
- Accepting changes updates your draft, not the published agent. Copilot never publishes on its own — publishing the change to production is always a separate, explicit step you take yourself.
What Copilot can do
Copilot has the same range of edits available as manual authoring in the flow builder, including:- adding, removing, and reconfiguring nodes
- converting a node from one type to another, carrying over compatible settings
- marking a node global and removing that mark
- adding, editing, and removing transitions, reordering them when order affects which one is evaluated first, and reordering the conditions inside a transition
- updating the flow’s global settings, dynamic variables, and voice settings
- changing who speaks first in the conversation, the pause before the start, and the first node
- building and converting MCP Tool nodes that call an external tool
- creating and configuring observers — detectors of conversation events; observer changes are written to the agent’s observers as soon as you accept them, not to the flow draft
MCP nodes
Copilot knows the MCP servers registered by your organization and the tools you have explicitly exposed on them, with their arguments. It proposes an MCP node only with values from that registry: a reference to a server or tool that is not in the registry is checked before the card is shown, and such a change arrives marked not applicable, with the reason. What Copilot receives is deliberately narrow — server names, references and descriptions, plus the exposed tools. Secrets, headers and endpoint addresses are not part of it. Copilot does not manage the registry: only a user creates a server and exposes a tool on it, in the MCP servers section.Reviewing proposed changes
Proposed changes arrive in the chat as one Changes · N card, and the affected nodes are marked on the canvas:- ‹ i / k › in the card header steps through the changes that are undecided; stepping forward scrolls the canvas to the element
- each change is a collapsed row with its type, target and status; one row at a time is expanded
- the expanded row shows the change as lines: removed with −, added with +; proposed and current switch what the row and the canvas show — the proposed or the current value
- Accept or Reject a single change; Undo is available only on the last decision and reverts it, and after Accept all it undoes the whole set
- a change that cannot be applied has Remove instead
- Accept all and Reject all in the card footer decide everything at once
When a change is not applicable
If some changes cannot be applied, Copilot names the real cause — with the exact path to the field that needs fixing. Downstream symptoms are not passed off as separate problems: they are marked as “depends on operation …”, so that one badly filled setting does not turn into five identical-looking changes marked not applicable with no indication of what to fix.
Guardrails on model and voice changes
In the editor Copilot does not change the agent model (including the classifier model), the speech recognition and voice synthesis providers and models, the VAD provider, or the realtime model and voice. Such changes arrive marked not applicable — change them manually in the agent settings. This keeps Copilot from affecting call quality or latency. A node’s own model and the node-level interruption sensitivity are edited like regular flow fields.Adding context to a message
The + button next to the message field opens a menu of context for Copilot to work from. Node (step), Past session and Test case open a list beside the menu; File opens the file dialog at once:- a specific node in the flow
- a past session of the agent (a chat or a call)
- a test case; the ▶ button in the test case list runs it
- a text file up to 200 KB; for a larger file Copilot shows “The file is larger than 200 KB. Attach a fragment.”

What Copilot receives
- The current agent draft — secret values in it are hidden.
- The context you attach. In attached calls, phone numbers and email addresses are partly hidden.
- On its own, Copilot reads only test sessions of the agent; it sees a real call only if you attach it.
Simulations and test cases
Ask Copilot to try out the flow without leaving the chat:- Run a simulation — Copilot plays the conversation against a simulated client, built from a persona or from predefined client lines. By default a simulation runs up to 12 turns, at most 40.
- Create a test case or a check scenario — Copilot writes them based on the conversation and can run them right away. The created scenarios appear on the Scenarios tab.

Watching Copilot think
Instead of a plain “thinking…” indicator, Copilot shows what it’s actually doing:- Reasoning — when the model provides it, you see its reasoning as it’s generated. The icon in the block shows or hides the reasoning; the step trace stays either way.
- Steps — an always-available trace of what Copilot is doing right now, for example reading the flow and checking its validity, reviewing attached context, running a simulation, or preparing the proposed changes. Each step finishes with a short result, such as how many assertions passed.
