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

# Workflows

> Orchestrate multiple agents in a graph with evaluators, checks, and breakpoints

## Overview

Workflows let you wire sub-agents into a **directed graph** that runs multi-step work deterministically — fan out tasks, evaluate results, loop on revisions, and pause for human input. Build and edit them visually in **Settings → Extensions → Workflows**.

## Templates

Start from a template instead of a blank canvas:

| Template                 | Shape                                                                            |
| ------------------------ | -------------------------------------------------------------------------------- |
| **Reviewer Loop**        | A worker implements, an evaluator reviews, and revise loops back until it passes |
| **Fan-Out + Synthesize** | Parallel branches do work, then a join merges the results                        |
| **Linear Pipeline**      | A straight sequence of nodes                                                     |
| **Blank**                | An empty canvas to build from scratch                                            |

## Role Agents

Workflow nodes can use purpose-built **role agents** with tools scoped to their job, so the boundary is physical — a reviewer literally has no edit tools and cannot implement even if asked.

| Role          | Tools               | Does                                                   |
| ------------- | ------------------- | ------------------------------------------------------ |
| **Developer** | Read + edit + build | Implements the change and confirms it builds           |
| **Reviewer**  | Read-only           | Judges the output and emits a pass/revise verdict      |
| **QA**        | Read + build        | Builds and runs tests, reports pass/fail               |
| **Planner**   | Read-only           | Turns a goal into an ordered plan for downstream nodes |

<Note>
  These role agents are **workflow-only** — they don't appear in the @-mention picker or the main agent's dispatch. You can also use your own [sub-agents](/features/subagents) as nodes.
</Note>

## Node Kinds

| Node          | What it does                                                                                    |
| ------------- | ----------------------------------------------------------------------------------------------- |
| **Worker**    | Runs an agent to perform a task. No verdict — it just hands off to the next node.               |
| **Evaluator** | Runs an agent that emits a verdict (**pass** or **revise**) the engine routes on.               |
| **Join**      | A convergence point: runs once after all incoming branches complete, aggregating their outputs. |
| **Manager**   | A router: picks one outgoing node to run next.                                                  |

## Edges & Routing

Edges connect nodes and carry a condition:

| Condition  | When it's taken                             |
| ---------- | ------------------------------------------- |
| **Always** | Unconditional handoff (typical for workers) |
| **Pass**   | When the source evaluator returns *pass*    |
| **Revise** | When the source evaluator returns *revise*  |

This lets you build pass/revise loops — an evaluator sends work back to a worker until it passes.

## Deterministic Checks

A node can run a **tool check** — a named tool (for example, `test_app`) that must succeed for the node to pass. If the tool errors, the check fails. This grounds a workflow in real signals like a passing build or test run, not just model opinion.

## Breakpoints (Human-in-the-loop)

| Breakpoint        | Behavior                                                              |
| ----------------- | --------------------------------------------------------------------- |
| **Before run**    | Pause before a node runs — review or edit the task, skip it, or abort |
| **After verdict** | Pause after an evaluator's verdict — accept it, override it, or abort |

## Building & Running

<Steps>
  <Step title="Create a workflow">
    In **Settings → Extensions → Workflows**, add nodes (workers, evaluators, joins, managers) and connect them with edges.
  </Step>

  <Step title="Add checks and breakpoints">
    Attach deterministic tool checks where you need hard gates, and breakpoints where you want to steer.
  </Step>

  <Step title="Run it">
    Start the workflow from the context picker in chat. It executes the graph and reports progress.
  </Step>

  <Step title="Inspect and steer the run">
    The run inspector is graph-first: it shows the workflow graph, then per-node results, verdicts, and metrics. While a workflow runs you can **pause**, **step**, or **terminate** it on demand.
  </Step>
</Steps>

<Tip>
  Start simple: a worker → evaluator → (revise loop back to worker / pass to join) covers a lot of ground before you add managers and parallel branches.
</Tip>

## Related

<CardGroup cols={2}>
  <Card title="Sub-agents" icon="robot" href="/features/subagents">
    The agents that power workflow nodes.
  </Card>

  <Card title="Tools" icon="screwdriver-wrench" href="/configuration/settings-overview">
    Deterministic checks call the same tools the agent uses.
  </Card>
</CardGroup>