Skip to main content

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. Copilot panel open in the agent editor with a conversation in progress

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
Copilot also answers questions about the platform using this documentation, with links to its pages, when documentation search is enabled on the platform.

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
Applicability is checked across the whole set. That matters for new conversation branches: a step may reference a node that another step of the same set creates. On its own such a step looks invalid, together it is not. Each change can be accepted separately; if it depends on others, Copilot asks you to apply them together: “This change depends on others in the set — apply them together (“Accept all”).”

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. Copilot proposal with a counter, per-change diff, and Accept/Reject controls

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.”
The + button's context menu: Node, Past session, Test case, and File You can also attach a call from the call card: Attach to Copilot opens the agent of that call with the Copilot panel and the call attached.

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.
Long context is shortened. If Copilot can’t finish within the allotted number of steps, it asks you to refine the request.

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.
The simulation card shows the result — PASS or FAIL when it has checks — the number of turns, the path through the nodes, the checks, and the transcript. Copilot uses the transitions and variables along the way in its answer. Simulations never send real requests to your integrations: HTTP functions get mock responses, and an MCP node goes to its error branch instead of a real call. Test cases can assert things like a node being reached (or not reached), a variable being set or equal to a specific value, and a transition not being taken. Simulation result: PASS badge, node path, assertions, and transcript On the Scenarios tab, Fix with Copilot sends Copilot a description of the problem with the conversations from the check attached. After you accept the fix, Check the scenario again appears.

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.
Stop interrupts the current turn. Completed steps, simulations and created test cases are kept, and a stopped turn has no proposed changes; Copilot replies “Generation stopped.”. In the conversation history a finished turn collapses to one line, Reasoning and actions · steps: N · time, and can be expanded again later. A Copilot turn with the Reasoning and actions block expanded: the steps and the model's reasoning

Conversation history

Copilot conversations are stored with the agent and visible to teammates who have access to it. A conversation’s title is the beginning of its first message. The panel header is a menu of Past conversations: pick one to come back to it. When a conversation is open, the header also has New chat and a button that copies a link to the conversation for a teammate. Use the feedback buttons on a response to rate it. An empty chat shows three suggestions, such as Add a step where we ask for the email. A click puts the text into the message field without sending it, so you can finish it first.