## What are Guide Steps?

Guide steps let you write multi-step instructions in natural language instead of building individual workflow steps. You can handle complex logic, data lookups, API calls, and responses within a single step.

## When to Use Guide Steps

### Use Guide steps when:
- Your workflow needs more than 5-6 individual steps
- The workflow is being used for live channels (chat, voice), which require more dynamic logic
- You need the same workflow to work across multiple channels (email + chat + voice)
- Your logic has several branching paths or conditions

### Don't use Guide steps when:
- You need a simple, single-purpose action (use regular workflow steps)
- You need very precise, technical integrations (use dedicated API steps)

## How to Build Guide Steps

### Basic Structure

Write instructions as if training a team member:

### Adding Dynamic Content

Type `@` or click "Insert block" to add dynamic elements:

### Variables

**Smart Fields** \- Reference or define smart fields:

These are reusable variables configured by going to **Configure > Info fields**. Use them to pull in values or dynamically assign new ones based on logic in the guide (e.g., if X, set field to Y).

* * *

**Workflow Data** \- Reference any outputs from earlier steps in the workflow.:

Any variables created by earlier steps in the same workflow (e.g., API calls, analyze case outputs, lookup results) are available to use in later Guide steps.

* * *

**Channel** \- Reference the user channel:

Adapt responses based on how the user contacted you (e.g., phone, chat, or email) without needing to build separate workflows.

### Integrations

**Google Sheets Lookup** \- Point to a Google Sheets spreadsheet and the AI will search, match, and retrieve data intelligently:

* * *

**API Endpoints** \- Call your configured APIs directly:

Once your APIs are configured via **Configure > Workflow API Endpoints** (with mapped smart fields and request bodies), you can call them directly within guides - no separate API steps needed.

* * *

**Knowledge Articles** \- Reference your knowledge base content:

The AI will use the article content to craft an informed, contextual reply - no need to copy/paste the full text or outline step-by-step instructions.

* * *

**Canned Responses** \- Reuse any existing Zendesk macros:

* * *

**Zendesk Ticket Updates** \- Dynamically set the ticket status and tags:

### Branching to Other Steps

**Create new steps:**

* * *

**Branch to existing steps:**

* * *

**Exit the guide:**

### Full Example

Here's an example Guide created to handle return requests:

## Building Your First Guide

#### Step 1: Write the Instructions

Start with plain language instructions, either modeled on or directly copied from existing SOPs:

```
1. Check their account
2. If account is good, process their request
3. If account has issues, explain how to fix them
4. Update the ticket
```

#### Step 2: Add Dynamic Elements

Replace variables and manual steps with `@` elements:

```
1. Check @account_status for email @customer_email
2. If @account_status equals "active", process their request
3. If @account_status equals "suspended", use @account_suspension_article
4. Update ticket status to "resolved"
```

#### Step 3: Test Thoroughly

Test with:
- Typical customer requests
- Edge cases (missing data, API failures)
- Different phrasings of the same request
- Unexpected customer responses