Skip to main content

Live Monitoring and Replay - Debug Agentic Flow Executions in ConvyAI

Overview​

Agentic Designer provides two ways to observe an Agentic Flow execution on the canvas:

  • Live monitoring - start a manual run directly from the canvas and watch each node execute in real time, or attach to a run already in progress from the Monitoring page.
  • Historical replay - re-examine any completed run as an animation, with full control over playback position.

Both modes set the canvas to read-only and visualize the execution path, but differ in entry point and session lifecycle.

Live monitoring​

A manual run lets you trigger an Agentic Flow execution directly from the canvas and observe it in real time, without going through the execution history afterwards. This is useful when you want immediate feedback during development - for example, when testing a newly wired integration or checking which node the flow reaches under a specific input.

Starting a run​

To start a manual run, click the start action on any trigger node in the canvas. The canvas immediately transitions to live debug mode - a brief intermediate state is shown while the run initializes.

Two conditions must be satisfied before you can start: the flow must be saved with no pending changes, and it must not be in Lock state (when locked, the start buttons on trigger nodes are hidden). If another manual run is already active on the same flow, the start buttons are disabled until that run completes.

Attaching from Monitoring​

You can also join an execution that is already in progress, without having started it yourself. On the Monitoring page, any run that has not yet reached a final state exposes an action to open it in live debug mode. This works regardless of who or what triggered the run, and even if the flow is currently locked for editing by another user - attaching in observation mode is not blocked by that lock.

Following the execution​

Once the run is active, the canvas becomes a live view of what is happening inside the flow. Nodes light up as they are reached: the node currently executing shows a progress bar to indicate it is in progress, while already-completed nodes and unreached ones have distinct appearances. As each branch is traversed, an animation highlights the connection in real time.

When you attach to a run already in progress from Monitoring, the canvas immediately reconstructs the state of every node executed before you joined, then continues live from that point.

The floating menu adapts to the live state: edit controls disappear and a continuous progress bar animates across the menu for as long as the run is active. At any point you can click Info to open the run detail panel and inspect the metadata of the run in progress - fields not yet populated show a dash.

Stopping a run​

If you need to abort the execution before it completes naturally, click Stop in the floating menu. The run terminates immediately and the canvas moves to the post-run state. Stop is available to anyone attached to the run, not only to the user who started it.

Multiple users can attach to the same run at the same time, whether it was started manually from the canvas or joined from Monitoring. Each user gets an independent, live view of the same execution.

Inspecting the result​

When the run ends - whether naturally or after a manual Stop - the canvas enters a post-run state. A persistent banner shows the final outcome and the completion timestamp. All nodes are now colored to reflect how each one ended, and every executed node shows how long it took to complete. The canvas remains read-only until you explicitly exit.

From this state you have two options: click Replay to watch the execution animation from the beginning (when it ends, the canvas returns to the post-run state), or click Exit debug to return to normal editing.

Errors during execution​

When a node ends with an error, it is highlighted immediately on the canvas with a visual indicator. Hovering over the indicator shows the error message in a tooltip. Execution then continues or stops depending on the error handling logic configured in the flow.

If you try to navigate away from the page while a run is active, a confirmation alert warns you that the execution will continue in the background and that you will not be able to return to the live view of this run. Refreshing the page while a run is active also triggers an alert, giving you the option to cancel.


Historical replay​

Replay is available to both agenticorchestrator_admin and agenticorchestrator_user roles.

Starting a replay​

Open the execution detail from the Monitoring page and click Replay. The canvas opens in read-only mode with the flow automatically centered and scaled to fit the window.

From the control bar you can step through the execution or jump directly to the end. The scrubber bar lets you move freely along the run timeline.

To resume editing, exit replay mode with End.

What you see on the canvas​

Executed nodes highlight in traversal order. Nodes that completed successfully are visually distinct from nodes that ended with an error. If the execution stopped due to an error, the replay halts at the same point and the failing node is highlighted immediately.

Each executed node displays the time it took during that run.

Clicking an executed node opens the detail panel with the input, output, and any error information recorded for that specific execution.

Execution details​

From the details modal you can review the run metadata and copy the execution ID to the clipboard.

Executed nodes panel​

The executed nodes panel lists the node executions of a run as a table, in chronological order. It complements the canvas: use it to follow the path of a run step by step, to see how long each node took and to export the data. It is available in live monitoring and in replay, to the agenticorchestrator_admin and agenticorchestrator_user roles and the higher user levels.

Click the panel button in the bottom action bar to open it. The panel is closed when you enter debug mode. It opens from the bottom, above the canvas, and you can resize and enlarge it so you can keep following the replay or the live run while it is open. The table is read-only.

Table columns​

The table has one row for each execution of a node: a node executed several times, for example in parallel branches or in a loop, has several rows. Rows follow the execution order. During a live run or a replay, new rows are added at the bottom as the nodes are reached.

ColumnDescription
PathColor of the execution path, the same shown on the canvas. It tells apart the nodes of parallel branches.
NodeName of the node.
EdgeRoute in the form <previous node> → <current node>, for example Trigger Manual → AI Agent. When parallel branches converge, only the previous node of the same path is shown.
StatusRunning, Success, Error, Warning, Interrupted, Disabled or Waiting. For Error and Warning, hover the icon next to the status to read the message.
Start / EndStart and end date and time of the node execution, to the millisecond.
DurationTime the node took.

A disabled node crossed by the path appears as Disabled: the run goes through it without executing it.

For an AI Agent node that invokes tools, the table shows a row for the agent and a row for each tool invoked, and the Edge column links them. AI Agent rows also show the input, output and thinking tokens, where available. Other nodes show no token information.

Export to CSV​

Click Export CSV to download the table. The action is available when the run is stopped: waiting, or ended with stop, end or error. The file is named after the flow and the execution ID, and has one row for each table row, in the same order.

ColumnContent
PathIdentifier of the path.
NodeNode name.
Node typeNode type.
Previous nodeNode that preceded the current one.
StatusNode status.
Start, EndDate and time in ISO 8601 format.
Duration (ms)Duration in milliseconds, as a number.
Input tokens, Output tokens, Thinking tokensOnly on AI Agent rows and where available.
MessageFull message, only for rows with Error or Warning status.

The file does not contain the input or output of the nodes.

  • Monitoring - view the execution list and access individual runs
  • Dashboard - aggregate view of executions across flows