Advanced Workflow Patterns

Once you're comfortable with the workflow builder and the node types, the real power comes from combining nodes into patterns that solve specific problems. This page walks through the patterns we see most often.

Each pattern below describes:

• The goal you're trying to hit
• Which nodes you'll use
• How to wire them together
• A tip to keep things sane

Routing user intent to specialized agents

Goal - Different kinds of requests get handled by different Agent nodes. A customer who says "I want to upgrade" goes to a sales Agent node; someone who says "I'm locked out" goes to a support Agent node.

Nodes - Start -> Classify -> multiple Agent branches

How to wire it:

1. Drop a Classify node after Start.
2. Define the categories you want to route to (e.g., sales, support, other).
3. Each category becomes its own output branch on the Classify node.
4. Connect each branch to its own Agent node with a tailored system prompt.

[Screenshot: Classify node with three branches connecting to three agents]

Tip - Keep your category set small (3-5). More categories make classification flakier, not better.

Conditional branching on a value

Goal - Route based on a specific, predictable condition - not on AI understanding. For example, premium customers see one flow; free customers see another.

Nodes - Start -> (any nodes that produce the value) -> If/Else -> branches

How to wire it:

1. Make sure the variable you want to branch on exists (either an input variable from Start or a value produced by an earlier node).
2. Add an If/Else node and reference that variable in the condition (e.g., plan equals "premium").
3. Wire each condition's output to a different downstream branch. The default Else branch catches anything that didn't match.

Tip - Use Classify when the input is fuzzy ("the user sounded angry"). Use If/Else when the input is exact ("the variable equals premium").

Storing and reusing data across steps

Goal - A value produced early in the workflow needs to be used later, in a node that doesn't directly connect to where it came from.

Nodes - Set State for writing, variable references for reading

How to wire it:

1. After the node that produces the value, add a Set State node and write the value into a named workflow variable (e.g., customer_email).
2. In any downstream node's settings, reference that variable by name.
3. The value is now available anywhere later in the workflow.

See Variables and Data for the full mental model of how data flows.

Tip - Use clear variable names. result_2 will haunt you in three weeks. extracted_email will not.

Reusable logic with Skills

Goal - You're solving the same sub-problem in multiple workflows (e.g., "look up a customer by email" or "format an address"). Don't rebuild it every time.

Nodes - Skill

How to wire it:

1. Build the reusable logic as its own self-contained workflow. Define its inputs and outputs clearly.
2. In another workflow, drop a Skill node and select the skill you built.
3. Pass inputs in; consume outputs as variables downstream.

Tip - Skills shine when the same logic shows up in three or more workflows. Don't over-abstract before you have evidence.

Running steps concurrently

Goal - Two or more things can happen at the same time and they don't depend on each other. Run them in parallel and shave latency.

Nodes - Parallel -> branches -> Join

How to wire it:

1. Add a Parallel node where the workflow needs to split.
2. Connect each independent branch off the Parallel node.
3. Add a Join node where the branches need to come back together. Join waits for every branch to finish before continuing.

Classic uses:

• Generate a title, an outline, and an image prompt all at once.
• Call three different APIs at the same time.
• Run a "fact check" agent in parallel with the main answer agent.

Tip - Parallel only helps if branches don't depend on each other. If branch B needs branch A's output, you're not parallel - you're sequential.

Calling external services mid-workflow

Goal - The workflow needs data from (or wants to push data to) something outside FormWise - your CRM, a Sheets doc, a webhook into another system.

Nodes - Webhook, plus connected integrations like MCP servers or Composio for action catalogs.

How to wire it:

1. For a one-off external call: use the Webhook node. Set the URL, method, headers, and body. Reference workflow variables in the body.
2. For an Agent node that should call an external service mid-conversation (e.g., "look up this user, then answer"): enable the right MCP server or Composio toolkit in the Agent node settings. The model decides when to call.

Tip - Webhook nodes run in the workflow. MCP/Composio tools run inside an Agent node when the model chooses to. Pick the one that matches who's making the decision.

Combining patterns

Real workflows combine several of the above:

Start
  -> Classify (sales / support / other)
       sales -> Agent (sales) -> Webhook (notify CRM)
       support -> Parallel
                   -> Agent (fetch order)
                   -> Agent (check warranty)
                 -> Join -> Agent (compose reply)
       other -> Agent (general)

Don't be afraid to build long, branching flows - they're easier to reason about than one giant Agent node doing everything.

Debugging a workflow

When a workflow doesn't behave the way you expected:

1. Open Execution History and find the run. You'll see each node's inputs and outputs.
2. Look at the first node that produced something surprising. That's usually where the issue is.
3. For Agent nodes, check the system prompt and the actual variables passed in. Most issues are "the Agent node didn't see the variable I thought it did."
4. For Classify nodes, look at the input - is it clear enough for the model to bucket it?
5. Re-run the same input from the test panel to iterate quickly. See Testing and Quality for setting up repeatable test cases.

Next steps