See what a flow did with one request
Find an execution of a flow, read its cost and the path it took node by node, and watch the executions that run or wait right now.
5 min read
An execution is one run of a flow: the request that came in, the nodes it passed, the model calls it made, what they cost and how it ended. This page is about where the console shows executions and how to read one.
Find an execution
Open the flow, then its Executions tab. It lists every execution of the flow, the newest first: the operation code over the id of the execution, its status, how long it took, its cost and when it started.
The filter of statuses, All statuses at first, narrows the list to the executions of one status.
Search execution ID finds one execution by its whole id — the one an answer of the SDK, a webhook or a support ticket carries. It takes digits only; the id of an execution of another flow finds nothing.
The cost is what the model calls of the execution were captured for. An execution that was refused, that failed or that is not settled yet shows a dash, and so does one answered from the cache, which costs nothing. The page of the execution says why.
The list is split into pages. Rows per page: sets how many executions a page shows, the numbers under the list move from page to page. A page keeps its rows while new executions come in; the first page shows the newest.
A row of Request paths on the Analytics tab opens the list on the executions of that path. Two filters above the list say so, each with a ×: the period the row was counted over, and the path, its nodes in order. Press one to clear it. A path is counted over its period, so clearing the period clears the path too.
When the filter or the search finds nothing, Clear filters shows every execution again.
Press a row to open the page of the execution. The page has an address of its own, so a link to it can be shared, and the browser's Back returns to the same page of the list.
What the statuses mean
| Status | The execution |
|---|---|
| Queued | Is accepted and has not started to walk the flow |
| Running | Is walking the flow |
| Waiting | Stands at a node and waits: for its delay, for a decision on an approval, for a free connection of a pool, or for a model call the provider runs in the background |
| Completed | Ended at Return Response |
| Rejected | Was refused: by a Reject Request node, or by a budget, a policy or the credits of a customer |
| Failed | Ended with an error that is not a refusal |
| Uncertain | Called a provider and never learned the outcome |
An execution is uncertain when the provider did not answer in time, or when it ran a model call in the background and Slen could not get its result. Its hold stays until it expires, because the provider may have been paid: check the call with the provider. Send a request says what each status means for the caller.
A wait has an end. An execution that has waited 72 hours in all, by default, is closed as failed with the code parked_expired — one that waits for a model call the provider still reports as running too.
Read an execution
The page of an execution opens with the operation code, the status and the whole id of the execution, then a row of facts: how long the execution took, when it started, what was Charged for it and the id of its operation, with a link to it.
When the execution did not end well, a block under them says how it ended: at which node it was refused or failed, why, and the error code that node decided. When the caller received another code — the code of a Reject Request node, for one — that code and its message stand under it. An execution that waits says at which node, for what and until when; one that runs says so, and the page follows it until it ends.
| Tab | What it shows |
|---|---|
| Steps | Each node the execution passed, in order: its status, the port it left through when that port means something, and how long it took. Press a node to see it beside the list: its Decision with the code and the model, and What happened — where it sent the request. Under a model node, its attempts. Event details under the list shows the events of the selected node |
| Trace | Every event of the execution in the order it happened, each with the milliseconds since the start |
At the foot of the page stands the cost: Estimated — what the model calls were expected to cost; Hold — what was held for them; Actual — what they were captured for, once that is known.
Actual comes after the end: the model calls are settled in the background. The page reads it by itself.
A request answered from the cache costs nothing; the cost then says what the cache saved, at the estimate.
Watch the executions as they run
Open the flow in the builder and switch the canvas to Live. The canvas then shows the path of each execution that runs, node by node, and the panel in its corner counts the executions that run and the ones that wait.
An execution that waits stays on the canvas, and the panel says at which node, for what and until when, when a clock decides it.
Executions that were already waiting when Live was turned on are read back too, up to the ten newest.
Open execution details opens the panel of the execution in focus, and Full page → in the panel opens its page.
The canvas shows the draft, and an execution runs the published version. A node it passed that the draft does not have is named in the panel instead.
Live is a way to read the flow, not to change it: the canvas cannot be edited in it.
Where to go next
AI flows — where the executions of a flow are.
Send a request — the answer your application gets for an execution.
Approvals — decide on an execution that waits for a person.
Operations, authorizations and the ledger — the model calls of every flow in one list.
Executions — read an execution and its trace over the API.
Pauses, queues and resuming — why an execution waits and how it goes on.