> For the complete documentation index, see [llms.txt](https://docs.uptiq.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.uptiq.ai/ai-workbench-qore/console/agent-builder/build/execution-plans.md).

# Execution Plans

Define reusable plans the agent follows when a request matches, and review the steps each one runs.

An **execution plan** is a reusable sequence of skill calls that the agent follows when a request matches it. Instead of planning every request from scratch, the planner picks the plan that best matches what the user wants and runs its steps. If no plan fits, the planner builds one at runtime.

Execution plans were called **checklists** in earlier versions of Qore. They are not the same as an evaluator's **Checklist** method in [Evals](https://docs.uptiq.ai/ai-workbench-qore/control-center/evals.md).

Execution plans also power the **Flow** tab on the Builder Canvas. When the agent has none, the Flow tab reads **No Plan Found**.

Open them from **Agent Config → Execution Plans**, under *Agent Setup*.

***

## The Execution Plans page

The page describes itself as pre-built execution plans for this agent, which the planner chooses from at runtime based on what the user wants. A green **Add Execution Plan** button sits at the top right. Below it, a table lists the agent's plans:

| Column          | Description                                                                                                |
| --------------- | ---------------------------------------------------------------------------------------------------------- |
| **Name**        | The plan's name, such as `Compose and Send Email`.                                                         |
| **When to use** | The kind of request the plan applies to, such as `User wants to compose and send an email to a recipient`. |
| **Steps**       | How many steps the plan has.                                                                               |
| **Actions**     | The `•••` menu for the row.                                                                                |

Each row is one reusable workflow the agent can follow.

## Add or edit a plan

Select **Add Execution Plan** to write a plan, or open a row's `•••` menu to change one. The plan opens in a window titled **Edit execution plan** when you edit it. It has these fields:

| Field           | Required | What to enter                                                                                         |
| --------------- | -------- | ----------------------------------------------------------------------------------------------------- |
| **Name**        | Yes      | A short name for the plan, such as `Compose and Send Email`.                                          |
| **When to use** | Yes      | The request or situation the plan applies to. The planner uses it to decide whether the plan matches. |
| **Summary**     | Yes      | What the plan does from start to finish, in a sentence or two.                                        |
| **Steps**       | —        | The ordered steps. Select **Add step** to add one.                                                    |

Each step is numbered (**Step 1**, **Step 2** and so on) and starts with a name, such as `Collect Email Details`. Select **Remove**, in red at the right of a step, to delete it. Select **Save changes** to keep your edits, or **Cancel** to close the window without saving.

For example, a plan named `Compose and Send Email` can have the summary `Guides the user through gathering recipient details, subject, and body, validating inputs, confirming the email contents with the user, and sending the email.` and four steps, starting with `Collect Email Details`.

Write **When to use** the way a user would ask. A plan only helps if the planner can tell, from the request, that it applies.

***

## How plans are created

You can write plans yourself, as above. Plans can also come from the agent's runtime planning. As the planner executes tasks successfully, recurring execution patterns can be converted into reusable plans. This lets the agent standardize workflows that are repeatedly used and improve consistency over time.

Rather than rebuilding the same workflow each time, the agent can reuse a known execution structure for similar requests.

***

## How plans relate to the rest of the agent

### Builder Canvas → Flow tab

The **Flow** tab visualizes the plans associated with the agent. When one or more plans exist, the tab displays the execution sequence and step structure. Without any, it reads **No Plan Found**.

### Skills & Capabilities

Each plan step executes a skill attached to the agent. A plan can only invoke skills that are currently available within the agent's configured capabilities.

### Triggers

Triggers determine **when the agent starts running**. Execution plans determine **how the agent executes once it starts**.

These systems operate independently:

* A trigger can invoke the agent without matching a plan.
* A plan can execute regardless of how the agent was triggered.

***

## When plans are useful

Execution plans are most valuable when:

* Similar requests are received repeatedly.
* The workflow requires multiple skills executed in a specific order.
* Runtime planning results have become inconsistent.
* Execution paths need to be easier to review, explain, or audit.
* Predictable execution is more important than planner flexibility.

## When dynamic planning is better

Dynamic planning remains useful when:

* Incoming requests are highly varied.
* The agent is still early in adoption and usage patterns are unknown.
* Workflows frequently change.
* A request type is too infrequent to justify a reusable plan.

***

## Why this matters

Execution plans help balance flexibility with consistency. The runtime planner can generate a workflow for almost any request, but dynamic plans may vary between runs depending on context and reasoning. For recurring workflows where the ideal path is already known, a reusable plan provides:

* More predictable execution
* Faster runtime planning
* Better operational consistency
* Easier debugging and auditing
* Clearer visibility into how the agent handles common requests

Most agents operate well without plans at first. Over time, as repeated patterns emerge, reusable plans become valuable for stabilizing and scaling agent behavior.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.uptiq.ai/ai-workbench-qore/console/agent-builder/build/execution-plans.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
