> ## Documentation Index
> Fetch the complete documentation index at: https://docs.iblueprint.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Run and monitor iBlueprint Blueprint executions
> Trigger iBlueprint Blueprints from the web UI, API, or CLI; track execution status node-by-node; and handle human-in-the-loop pauses and failure recovery.
When you execute a Blueprint, iBlueprint runs each node in sequence, passing the output of each step as the input to the next. This page explains how to trigger an execution, what happens during the run, how to monitor progress, and how to handle nodes that require human input before the chain can continue.
## How execution works
Blueprint execution is always **sequential**. Nodes run one at a time in the order they appear in the chain:
1. The execution engine resolves all `{{variable}}` references in the first node's configuration.
2. The first node runs and produces an output.
3. The output is stored and made available to the next node as its input.
4. Steps 1–3 repeat for every subsequent node.
5. When the last node completes, the execution is marked as `completed`.
If any node fails and is not handled by a `conditional` node, the execution stops immediately with a `failed` status.
## Execution statuses
| Status | Meaning |
| ----------- | ---------------------------------------------------------------------------------- |
| `running` | At least one node is actively executing. |
| `completed` | All nodes ran successfully. |
| `failed` | A node encountered an unrecoverable error. |
| `paused` | A `human`, `human_checkpoint`, or `approval_gate` node is waiting for human input. |
| `cancelled` | You or an API caller cancelled the execution before it finished. |
## Triggering an execution
Navigate to your Blueprint from the dashboard and open it in the editor.
Click the **Run** button in the top-right toolbar. If the Blueprint declares input variables, a dialog appears asking you to fill them in.
Fill in any required variable values, then click **Execute**. The execution panel opens automatically and shows live progress.
Call the execute procedure with your Blueprint ID and any input variables:
```bash theme={null}
curl -X POST "https://api.iblueprint.ai/api/trpc/blueprint.execute" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"json": {
"id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
"variables": {
"topic": "AI in healthcare",
"language": "en"
}
}
}'
```
The response includes an `executionId` you can use to poll for status:
```json theme={null}
{
"result": {
"data": {
"json": {
"success": true,
"executionId": "exec_1733050800000_a3b7z"
}
}
}
}
```
Use the `iblueprint execute` command with your Blueprint ID and a JSON inputs string:
```bash theme={null}
iblueprint execute 3fa85f64-5717-4562-b3fc-2c963f66afa6 \
--inputs '{"topic":"AI in healthcare","language":"en"}'
```
The CLI prints the execution ID when the run starts:
```
Execution started, ID: exec_1733050800000_a3b7z
```
Check the status at any time using the returned execution ID:
```bash theme={null}
iblueprint status exec_1733050800000_a3b7z
```
## Monitoring execution
### Execution log
Every execution generates a step-by-step log you can access from the **Executions** tab on any Blueprint. The log shows:
* The status of each node (`pending`, `running`, `completed`, `failed`, `skipped`)
* The input passed to each node
* The output produced by each node
* Timing and token usage for LLM nodes
* Error messages for failed nodes
### Status polling (API)
If you triggered an execution via the API, poll the status procedure using the `executionId`:
```bash theme={null}
curl -G "https://api.iblueprint.ai/api/trpc/execution.getExecutionStatus" \
--data-urlencode 'input={"json":{"executionId":"exec_1733050800000_a3b7z"}}' \
-H "Authorization: Bearer YOUR_API_KEY"
```
```json theme={null}
{
"result": {
"data": {
"json": {
"id": "exec_1733050800000_a3b7z",
"status": "completed",
"progress": 100,
"totalSteps": 3,
"completedSteps": 3,
"failedSteps": 0,
"steps": [...],
"endTime": "2026-05-12T10:00:03Z"
}
}
}
}
```
Execution results are retained for 30 days. After that, they are automatically purged. Export important results before they expire.
## Human-in-the-loop
When a Blueprint contains a `human`, `human_checkpoint`, or `approval_gate` node, execution pauses when that node is reached. The execution status changes to `paused` and iBlueprint notifies the designated reviewer or approver.
**What happens during a pause**
The chain stops at the human node. All previously completed nodes retain their outputs, and no downstream nodes run yet.
iBlueprint sends a notification (email, in-app, or webhook, depending on your settings) to the person or role assigned in the node's `assignee` configuration.
The reviewer opens the paused execution from their dashboard, reviews the context, fills in any requested fields (for `human` nodes), and submits their response or approval decision.
The human node's output (the reviewer's response) is passed to the next node and the chain continues from where it left off.
If a human node has a `timeout` configured and the reviewer does not respond within that window, the execution transitions to `failed`. Make sure reviewers are aware of any time constraints before you deploy a Blueprint with approval gates.
## Cancelling an execution
You can cancel a running or paused execution at any time from the **Executions** tab on your Blueprint by clicking **Cancel**.
Cancelled executions retain their partial logs and the outputs of any nodes that completed before cancellation.