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

# Scout Workflows: Automate Multi-Step Processes at Scale

> Scout workflows connect your tools, respond to events and schedules, and run reliably at scale. Use Agent Blocks to add AI judgment to any automation.

Workflows are Scout's automation backbone. They connect your tools and services, respond to triggers, and execute sequences of actions — with branching logic, error handling, and AI judgment built in. You define the steps, and Scout runs them exactly as designed, every time.

## What Are Workflows?

A workflow is a series of connected blocks that run in response to a trigger. Each block performs one job — calling an API, evaluating a condition, running an AI agent, or transforming data — and passes its output to the next block in the chain. Workflows let you build processes that are too complex or too repetitive to handle manually, and automate them with confidence.

Common use cases include:

* A new lead fills out a form → add to CRM, research their company, notify your sales team
* A meeting ends on Zoom → transcribe the recording, extract action items, send a follow-up email
* A support ticket is created → categorize it, suggest a response, escalate if urgent
* A calendar event approaches → prepare a briefing, attach relevant documents, notify attendees

## When to Use Workflows vs. Agents

Workflows and agents solve different problems. Use the table below to choose the right tool for your situation.

| Aspect           | Workflows                             | Agents                            |
| ---------------- | ------------------------------------- | --------------------------------- |
| **Best for**     | Predictable, repeatable processes     | Open-ended, adaptive tasks        |
| **Control flow** | Predefined steps and branches         | Agent decides the approach        |
| **Triggers**     | Events, webhooks, schedules           | Chat messages, mentions           |
| **Consistency**  | Same output every time                | May vary based on context         |
| **Complexity**   | Excellent for multi-step integrations | Better for nuanced judgment calls |

**Choose workflows when:**

* You know the exact steps in advance
* You need reliable, repeatable automation
* The process should run automatically on a trigger
* Multiple tools need to be connected in sequence

**Choose agents when:**

* The task requires creativity or judgment
* The approach isn't predictable in advance
* You want conversational, back-and-forth interaction
* The system needs to adapt to unexpected situations

## Triggers

Every workflow starts with a trigger — the event that kicks off a run. Scout supports four trigger types:

* **Webhooks** — HTTP requests sent from an external service (payment system, form tool, CRM)
* **Schedules** — Time-based execution using cron syntax (daily, weekly, on a specific interval)
* **Events** — Scout-native events such as an agent completing a task or a file being uploaded
* **Integrations** — Native triggers from connected tools like calendar reminders or incoming emails

## Blocks

Blocks are the individual units of execution inside a workflow. Each block takes inputs, performs exactly one job, and produces structured output that the next block can use.

<CardGroup cols={2}>
  <Card title="Action Blocks" icon="bolt">
    Perform operations — call external APIs, write to databases, send notifications, or push data into connected tools.
  </Card>

  <Card title="Agent Blocks" icon="robot">
    Run an AI agent as a step in your workflow. Use these when a decision requires language understanding or judgment.
  </Card>

  <Card title="Condition Blocks" icon="code-branch">
    Branch your workflow with if/else or switch logic. Route data to different downstream blocks based on any value.
  </Card>

  <Card title="Transform Blocks" icon="shuffle">
    Reshape, filter, or restructure data between steps. Keep downstream blocks clean by normalizing inputs here.
  </Card>
</CardGroup>

## Data Flow Between Blocks

Each block outputs structured data that downstream blocks can reference directly. You connect blocks by mapping output fields to input fields — click an output handle and drag it to the next block's input handle in the Studio canvas.

Once connected, reference any prior block's output using double-brace syntax:

```
{{ block_id.output }}
```

For example, if your first block has the ID `classify_ticket`, the next block can read its result as `{{ classify_ticket.output }}`. This makes it straightforward to build chains where each step enriches or transforms data before passing it on.

## Error Handling

Workflows include built-in error handling so failures don't silently break your automation.

<CardGroup cols={2}>
  <Card title="Retry behavior" icon="rotate-right">
    Configure per-block retry logic for transient failures like network timeouts or rate limits.
  </Card>

  <Card title="Fallback paths" icon="arrow-right-arrow-left">
    Set alternate branches for expected failure cases so your workflow degrades gracefully.
  </Card>

  <Card title="Failure notifications" icon="bell">
    Get alerted immediately when a run fails so you can investigate before it impacts users.
  </Card>

  <Card title="Execution logs" icon="list">
    Review the full block-by-block trace of every run to pinpoint exactly what went wrong.
  </Card>
</CardGroup>

## The Power of Agent Blocks

Workflows don't have to be rigid. Drop an Agent Block into any workflow to add AI judgment exactly where you need it, without sacrificing the reliability and structure of the surrounding automation.

Here's what that looks like for a support ticket workflow:

```
1. Webhook trigger fires when a ticket is created
2. Transform Block extracts subject, body, and customer ID
3. Agent Block reads the ticket and decides:
   - "billing"  → route to billing queue
   - "bug"       → create a GitHub issue, assign to engineering
   - "general"  → draft a reply, assign to support
4. Condition Block checks the agent's output and routes accordingly
5. Action Blocks execute: post to Slack, update CRM, send confirmation email
```

The agent handles the judgment call. The workflow handles the execution. You get both reliability and adaptability — without choosing one over the other.

## Getting Started

<Steps>
  <Step title="Open Workflows in Studio">
    Navigate to **Studio → Workflows** from the left sidebar.
  </Step>

  <Step title="Create a new workflow">
    Click **New Workflow** and give it a descriptive name that reflects its purpose.
  </Step>

  <Step title="Add a trigger">
    Choose a webhook, schedule, event, or integration trigger to define what starts your workflow.
  </Step>

  <Step title="Build your block chain">
    Add blocks from the block library and connect them by dragging output handles to input handles.
  </Step>

  <Step title="Test in Console">
    Click the play icon to open the Console. Run the workflow with a real input payload and inspect each block's output.
  </Step>

  <Step title="Activate your workflow">
    Once your tests pass, activate the workflow. It will begin running automatically when its trigger fires.
  </Step>
</Steps>

## Next Steps

<CardGroup cols={2}>
  <Card title="Creating Workflows" icon="hammer" href="/workflows/creating-workflows">
    Define objectives, inputs, and outputs before you build — and follow the validate-fetch-decide-act-return pattern.
  </Card>

  <Card title="Blocks" icon="cubes" href="/workflows/blocks">
    Learn which block types to use and when, including how to pass data between them.
  </Card>

  <Card title="Running Workflows" icon="play" href="/workflows/running-workflows">
    Execute workflows from the Studio UI, REST API, Python SDK, or TypeScript SDK.
  </Card>

  <Card title="Environments" icon="layer-group" href="/workflows/environments">
    Promote changes from development to production and roll back safely when needed.
  </Card>

  <Card title="Logs" icon="magnifying-glass" href="/workflows/logs">
    Debug failures and monitor performance with block-level execution traces.
  </Card>
</CardGroup>
