> ## Documentation Index
> Fetch the complete documentation index at: https://ekso.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Prompts

> MCP Prompts — conversation templates that guide AI agents through multi-step planning workflows.

## What are MCP Prompts?

MCP Prompts are **conversation templates** that prime an AI assistant with context and step-by-step instructions for common workflows. Unlike tools (which perform actions) or resources (which provide reference data), prompts return pre-built messages that set up a guided conversation.

When an AI client invokes a prompt, it receives one or more `ChatMessage` objects that frame the user's intent and include any pre-loaded data. The AI assistant then responds naturally — using tools to carry out the steps described in the prompt.

Prompts are **read-only** — they don't modify data directly. They guide the AI to use tools.

## Available prompts

| Name            | Arguments                | Description                                                                        |
| --------------- | ------------------------ | ---------------------------------------------------------------------------------- |
| `create_item`   | `container?`, `process?` | Guide through creating a new work item with dynamic field discovery                |
| `find_items`    | `container?`             | Guide through finding and filtering work items using conditions                    |
| `setup_board`   | —                        | Guide through creating a new delivery board with containers, resources, and budget |
| `plan_sprint`   | `board?`                 | Plan a sprint: select items, assign resources, and set up a cycle                  |
| `review_sprint` | `board?`, `cycle?`       | Review sprint progress: item status, completion, budget vs actuals                 |
| `close_sprint`  | `board?`, `cycle?`       | Close a sprint: handle incomplete items, review outcomes, close the cycle          |
| `standup`       | `board?`, `cycle?`       | Daily standup: what's done, in progress, and blocked in the current sprint         |

### Static vs dynamic prompts

* **Static** (`setup_board`) — Returns fixed instruction messages. The AI discovers live data by calling tools during the conversation.
* **Dynamic** (`plan_sprint`, `review_sprint`, `close_sprint`, `standup`) — Fetches live tenant data (boards, cycles, items) and includes it directly in the prompt messages, giving the AI immediate context to work with.

Dynamic prompts accept optional `board` and `cycle` arguments — you can pass either a **name** or an **ID**. When omitted:

* If the tenant has a single board, it's auto-selected.
* The most recent open cycle is auto-selected.
* If multiple boards exist and no `board` is provided, the prompt lists all boards and asks the user to choose.

## How AI clients use prompts

Prompts are discovered and invoked via the standard MCP protocol methods:

```text theme={null}
prompts/list   → returns all 7 prompts with names, descriptions, and argument schemas
prompts/get    → returns ChatMessage list for a specific prompt (with optional arguments)
```

### Example: Daily standup

An AI client calls `prompts/get` with:

```json theme={null}
{
  "name": "standup",
  "arguments": {
    "board": "Sprint Board"
  }
}
```

The server responds with a `ChatMessage` containing:

* The board and cycle context (name, dates, budget)
* Items grouped by phase (Open, Working, Closed)
* Instructions for the AI to present a concise standup summary

The AI assistant then formats this into a readable standup report and highlights blockers.

## Prompt details

### create\_item

Pre-loads containers and processes. The AI guides the user to:

1. Select a container (or shows available containers)
2. Select a process type
3. Discover available fields via `get_item_screen`
4. Collect required and important optional field values
5. Create the item via `create_item`

### find\_items

Pre-loads containers. The AI guides the user to:

1. Select container(s) to search
2. Understand what the user is looking for in plain language
3. Discover filterable fields via `get_filter_fields`
4. Look up valid values for list-type criteria (status, priority, etc.)
5. Build conditions and call `filter_items`
6. Present results and offer to page through additional results

### setup\_board

Guides the user through creating a new board from scratch. The AI is instructed to:

1. List available containers (`get_containers`)
2. List available teams/groups (`get_user_group_list`)
3. Ask about budget hours
4. Create the board (`create_board`)
5. Optionally create the first cycle (`create_cycle`)

### plan\_sprint

Pre-loads boards, open cycles, and board containers. The AI guides the user to:

1. Select or create a cycle
2. Find unplanned items via `filter_items` or `search_items`
3. Plan items into the sprint with `plan_item`
4. Summarize the planned sprint

### review\_sprint

Pre-loads cycle items grouped by status phase (Open / Working / Closed), budget vs actual hours, and at-risk items (no estimate or no resource). The AI:

1. Summarizes progress as percentage complete
2. Highlights at-risk items
3. Flags items unlikely to finish by sprint end
4. Suggests corrective actions

### close\_sprint

Pre-loads incomplete items and identifies the next open cycle for rollover. The AI guides:

1. Deciding what to do with each incomplete item (move, unplan, or close)
2. Summarizing sprint outcomes
3. Closing the cycle via `update_cycle`

### standup

Pre-loads cycle items by phase for a quick daily summary. The AI presents:

1. **Done** — Recently completed items
2. **In Progress** — Active items with assignees
3. **Blocked / Needs Attention** — Items stuck or missing data