Conversational Agent

The Conversational Agent node runs an LLM-driven turn in a chat conversation, looping through reasoning and tool-calls and streaming them to the chat.

What it does

Runs a single turn of a conversational AI agent that you author in the canvas. You configure a model, instructions, and tools, then pass in the conversation context (which includes the chat history) emitted from a Wait for Message node. The agent performs a loop of reasoning and tool-calls, streaming them to the chat.

Note:

The agent can only reply within an exchange that a user has initiated, which means the user must send a message first before a conversational agent node can run. Flow-initiated exchanges — sending a message without a prior user turn — are not yet supported.

When to use this

Situation	Use
You need an LLM-driven, streamed conversational response, with possible tool-calls.	Conversational Agent
You need a deterministic reply in the conversation (no LLM).	Send Message
You need an LLM-driven execution with possible tool-calls, but without streaming to the conversation.	Autonomous Agent

Note:

Since the Conversational Agent node streams and appends its response to the chat automatically, you do not need to use Send Message to emit the agent's response to the conversation.

Visit build a chat agent workflow for a step-by-step example that combines Conversational Agent nodes with the other Chat nodes.

Adding an agent

Add the node, then configure it in the properties panel.

1. Select the + button on an output handle, or open the node palette from the bottom toolbar.
2. Select the Agent category, then Conversational Agent. Flow adds the node and opens its properties panel.
3. Configure the model, system prompt, and the conversation context binding, as described below.

Result: The Conversational Agent node is added to the canvas with its properties panel open, ready to configure.

Configuration reference

Field	Required	Default	Description
Model	No	Organization default agent model	The large language model (LLM) the agent uses. Select a model from the picker, which lists the models available to your organization.
System prompt	Yes	None	The agent's role and standing instructions: who it is and how it should behave. Applies to every turn of the conversation, so write durable guidance — e.g. persona, tone, goals, and when to call tools.
Temperature	No	0	Sampling randomness, from 0 to 1. Lower values make responses more deterministic; higher values make responses more varied or creative.
Max. tokens per response	No	8192	Maximum length of each model response within a turn. The ceiling depends on the selected model.
Conversation context	Yes	None	The conversation context object — containing the chat history — from an upstream Wait for Message, e.g. $vars.waitForMessage1.output.conversationContext

Output variables

In addition to the agent's conversational response, you may optionally configure structured output variables in the Outputs section of the properties panel.

These outputs are not seen by the user in the chat — instead, they are useful for setting goal-oriented or routing variables to use in downstream nodes within the Flow.

Each output variable you declare becomes a field on the agent's output object, referenced as $vars.<agentName>.output.<name>. Give each one a name and a type, then instruct the agent in the variable's Description field how to populate it.

Important:

Generation of the agent's conversational responses is driven by only its system prompt, while generation of the agent's outputs are driven by a combination of its system prompt and the output variable descriptions. To ensure the agent doesn't emit structured output data into the chat, use the system prompt to tell the agent how to respond in the chat, while using the output descriptions to instruct the agent how to fill in the outputs.

For example:

System prompt: "Thank the user when they would like to end the conversation."

Output variable: endConversation (boolean). Description: "Set to true when the user intends to end the conversation."

Branching on the result

Follow the agent with a Decision or Switch to route on a structured output field. For example:

Wait for Message → Conversational Agent (supervisor) → Switch on $vars.agent.output.intent
  → 'intent-a':  Route to a loop with specialist conversational agent A
  → 'intent-b':  Route to a loop with specialist conversational agent B
  → 'off-topic': Send Message ("Message is off-topic") → back to first Wait for Message.

Resources

A Conversational Agent composes with resource nodes you connect to its handles. The node has three resource handles, each with its own label in the canvas: Tools, Context, and Escalations. Connect a resource to a handle, then configure that resource in its own properties panel. The resources travel with the flow.

Each handle accepts only its matching resource type. The canvas blocks connections that don't fit, so you can't, for example, wire a tool to the context handle.

Tools

Connect tools to the Tools handle to give the agent capabilities it can call while reasoning. The agent decides during its loop whether and when to call each connected tool. Each tool carries a description that tells the agent what the tool is for, so write clear descriptions when a tool exposes one.

The tool types you can connect are:

• Built-in tools, three ready-made tools described below.
• Connector tools, which let the agent call an Integration Service operation, for example sending an email or creating a record in a downstream system.
• RPA Workflow and API function tools, which let the agent invoke a published RPA process or API workflow as a tool.
• Model Context Protocol (MCP) server tools, which expose the tools published on an MCP server.

Built-in tools

Three built-in tools ship with Flow. Each is a self-contained resource you connect to the Tools handle and configure in its own panel.

• Analyze Files: analyzes one or more files with an LLM to extract, synthesize, or answer questions about their content. Describe the files the agent will pass in and the analysis task to run on them.
• Batch Transform: processes and transforms a CSV file row by row. Provide the source file, describe the per-row task, and define the output columns the tool adds. You can enable or disable web search grounding for the transformation.
• Summarize: produces a synthesis across documents (up to 1,000 pages) with citations. Provide the source, describe what to synthesize, and choose the file extension. When the source is a PDF, you can turn citations on or off.

MCP server tools

Connect a Model Context Protocol (MCP) server to expose its tools to the agent. Selecting one or more tools from the server adds a Tool configuration section beneath the tool picker, with an expandable panel per tool. In that panel you can edit each argument's description, view the tool's full input and output schema, and choose how the argument gets its value: the agent decides at runtime, the value is bound to an in-scope agent variable, or the value is fixed (and optionally flagged as sensitive).

An MCP server's tool list can come from two discovery modes:

• Cached: takes a snapshot of the server's tools when the server is connected. Use Refresh tools on the server to pull an updated snapshot on demand.
  • By default, the Refresh schema before call toggle in a tool's configuration panel re-checks the server for the tool's current schema right before each call, so a schema change on the server (a renamed or added parameter, for example) doesn't require a manual refresh. When disabled, the tool always uses the schema from the last snapshot.
• Dynamic: discovers tools at runtime on every call, including tools added to the server after the node was configured.

For remote MCP servers, refreshing polls the server's discovery endpoint for asynchronous completions. For Platform MCP servers — UiPath-native services such as Document Understanding — the tool list comes from the UiPath Platform service catalog instead.

If no MCP server is connected yet, add one from the node palette's MCP server entry. The Create new options group server creation by subtype — Platform, Remote, Command, Coded, and UiPath. Selecting Platform opens a dialog to create the server within the current solution, when supported by your environment; the other subtypes open the corresponding creation page in Orchestrator. For more details, see About MCP Servers.

Note:

The inline Conversational Agent node does not yet support personal connections, client-side tools, or tool-call confirmations. To use these, build the agent in Agent Builder and import it as a node in your Flow.

Context

Connect a context resource to the Context handle to ground the agent in your data. The agent draws on this grounding data while reasoning instead of relying on the model alone. A context resource points at a context index in your organization.

Configure how the agent retrieves from the index, including the retrieval mode (semantic, structured, DeepRAG, or batch transform), the query, the number of results to return, a relevance threshold, and whether to include citations. To create a new context index, use the Create new Context action on the handle's add panel, which opens index creation in a new tab.

Escalation

Connect the Escalations handle to route to a person when the agent reaches a case it shouldn't decide alone. The agent pauses, a human acts on the escalation, and the agent resumes with the outcome. You can attach either of two escalation resources:

• Escalation: routes to an action app task. Configure the action app, recipients, notifications, the inputs passed to the app, and how the app's outcome maps back to the agent.
• Action App Escalation: routes to a coded action app, with the same recipients, notification, input, and outcome-mapping configuration.

Both escalation resources are configured the same way. Choose Action App Escalation when your escalation target is a coded action app rather than a standard action app.

Important:

An escalation from a Conversational Agent blocks the conversation turn — the user is left waiting on the chat surface until the human acts. For long-running approvals or hand-offs where the conversation should keep moving, run a Human Task from a parallel branch instead, so the chat can continue while the approval happens in the background.

Common issues

An input validation error appears before you can debug. The Model, System prompt, and Conversation Context are all required. The node reports a validation error until each one is set.

The chat blocks for a long time after the agent triggers an escalation. Escalations attached directly to the agent pause the entire turn until the human acts. For long-running approvals, move the human step to a parallel Human Task branch that runs alongside the conversation instead.

A connected Batch Transform tool reports a validation error. Batch Transform requires at least one output column. Define the columns the tool should add before you debug the flow.

Related pages

• Wait for Message — provides the conversation context this node consumes.
• Send Message — deterministic (non-LLM) response alternative.
• Chat — full palette of chat conversational nodes.
• Build a chat agent workflow — end-to-end walkthrough that combines a supervisor and specialists.
• Chat deployment — publish and expose the Flow through various channels.
• Autonomous Agent — task-executing LLM-driven loop without streaming to the conversation.