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

# Workflows

> Understand workflows as durable graphs where data moves through configured steps and inspectable runs.

Workflows are durable process graphs. They turn repeated delegation into a process that can pause, branch, retry, ask for approval, and explain what happened later.

A workflow combines deterministic orchestration with agent judgment:

* **Workflow:** controls order, branches, waits, and durable state.
* **Agent:** handles language, judgment, research, and tool use.
* **Fleet:** coordinates declared specialist work and joins the results.
* **Channel:** can provide a trigger, data, approval surface, or destination.
* **Run console:** shows the execution evidence for one run.

## In -> Configure -> Out

Every step follows the same mental model:

```text theme={null}
Data in  ->  Configure the step  ->  Data out
```

### In: Data From Earlier Steps

Data in is the set of values a step can receive from the trigger and upstream nodes.

Studio groups those values by source step. A channel trigger might provide message text and author. An agent task might provide `intent`, `sentiment`, and `order_id`.

When you insert a value into a field, Studio shows a source-colored pill. The stored reference remains structured, while the editor keeps the human-readable source and field visible.

Only output from a step that is guaranteed to run on every path before the current step is eligible. This prevents a converged branch from depending on a value that another branch may never produce.

### Configure: Say What This Step Should Do

The middle of the model is the step's plain-language form:

* choose an agent, channel, connector, workflow, or approver
* write an instruction, question, or message
* define conditions and branch behavior
* set timeouts, join policies, and other controls
* insert upstream values as pills
* declare structured return fields when a node supports them

Advanced JSON remains an escape hatch for unusual cases, not the normal authoring path.

### Out: A Contract For Later Steps

Data out is the successful result made available downstream.

Each built-in node descriptor declares its output schema. Agent and collaboration nodes can refine that contract with fields configured by the workflow author. Studio uses the same metadata for:

* output pills on canvas nodes
* the upstream-values menu
* the inspector Docs tab
* validation and run inspection
* the generated [workflow node reference](/reference/workflow-node-reference)

Some outputs are fixed, such as a condition's branch and boolean result. Others are dynamic, such as selected data fields, agent output, code-runner output, or a child workflow's result. Test runs reveal concrete values alongside the declared contract.

## The Graph Is The Process; A Run Is One Execution

The draft graph describes what may happen. A run records what did happen.

A run pins the workflow version and records:

* trigger and input
* step input and output
* queued, running, waiting, completed, skipped, and failed states
* selected branches
* waits and human decisions
* agent and fleet child work
* artifacts, errors, duration, and available usage/cost data

Live and historical runs use the same canvas projection. Selecting an earlier run repaints the graph with its path and statuses without modifying the workflow.

## Node Families

| Family         | Role in the graph                                                        |
| -------------- | ------------------------------------------------------------------------ |
| Triggers       | Start a run from a manual action, webhook, schedule, or channel message. |
| Flow control   | Choose branches, merge paths, stop successfully, or fail deliberately.   |
| Data           | Set, select, map, transform, or merge values.                            |
| Waits          | Pause for time, a callback, or a channel reply.                          |
| Human steps    | Ask for approval, input, or a choice.                                    |
| Agents         | Assign structured work to one agent or a collaboration group.            |
| Fleet          | Coordinate multiple participants and explicit join behavior.             |
| Workflows      | Run another published workflow as a step.                                |
| Code           | Run user-authored code through the isolated runner boundary.             |
| Actions        | Prepare messages and HTTP work under governance.                         |
| Connected apps | Prepare an action through a configured connector.                        |

See every built-in type in the [workflow node reference](/reference/workflow-node-reference).

## Drafts And Published Versions

Studio edits a draft package. Publishing validates it and creates an immutable version.

Runs reference the version they executed, so later draft changes do not rewrite history. This separation is what makes replay, audit, and comparison trustworthy.

## When To Create A Workflow

Create a workflow when work should be repeated, approved, inspected, retried, or improved over time.

Use direct agent delegation for one-off exploration where a conversation or single deliverable is enough.

## Related Pages

* [Build a workflow](/guides/build-a-workflow)
* [Workflow Studio](/product/workflows)
* [Run history and approvals](/operations/run-history-and-approvals)