> ## Documentation Index
> Fetch the complete documentation index at: https://docs.beam.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Creating Flows
> Design structured execution paths for AI agents with visual workflow builder, nodes, branches, and conditional logic
Flows define how your AI agent executes tasks through a graph-based structure of nodes, branches, and decision points. This enables intelligent automation that adapts dynamically to input data and real-time conditions.
## Understanding Flows
A **flow** is a graph-based structure that defines agent execution. It consists of:
Actions the agent performs using tools (AI processing, integrations, data operations)
Conditional paths with unique edge selection criteria determining the next node
Points where multiple branches converge back into a single execution path
## Building Flows: Step-by-Step
### Step 1: Creating Nodes
Every flow is built from **nodes**, and every node requires a **tool** to execute its action.
Click the **+ icon** on the canvas to create a new node. You'll see options to:
* **Insert a step**: Add a new node with a tool
* **Add a branch**: Create conditional logic paths
* **Add an exit**: Define workflow termination point
Select **"Insert a step"** to add a new node.
Add a clear **objective** describing what the node should accomplish
**Example Objectives:**
* "Extract customer email and order number from request"
* "Send confirmation email to customer"
* "Create new support ticket in Salesforce"
* "Check if order exists in database"
Choose ONE tool that defines what the node does:
**Option A: Match Tool**
* Automatically pick the tool that fits your objective
* System suggests best tool based on node description
* Reuse tools across different agents
**Option B: Generate Tool**
* Let AI generate a new tool for you
* Create new Custom GPT tool for AI-powered processing
* Define prompt for classification, extraction, or analysis
* Configure output schema
**Option C: Choose Manually**
* Browse and select a tool from the catalog
* Browse 1500+ integration connectors
* Choose actions like "Gmail - Send Email" or "Airtable - Create Record"
* Connect external systems and platforms
Map data to the tool's input parameters using variable fill methods:
**Every node has access to:**
* **`task_query`**: The trigger input that started the workflow (available to ALL nodes)
* **Previous node outputs**: Via Linked variable fill method
* **Memory context**: Historical data from past interactions via From Memory fill
* **Static values**: Fixed configuration data defined in the workflow
* **User inputs**: Values provided at runtime via User Fill method
* **AI-extracted values**: Data extracted from context via AI Fill method
**See [Variables & State](/02-building-agents/agent-fundamentals/variables-state/variables-state) for detailed variable fill configuration.**
**Understanding Tool Types:**
**1. Prompt-Based Tools (Custom GPT)**
* AI-powered processing using language models
* Classify, extract, or analyze data
* Generate structured outputs based on prompts
* Example: Email Classifier, Invoice Extractor, Sentiment Analyzer
**2. Integration Tools** (from catalog OR custom)
* **From Integration Catalog**: Pre-built connectors to 1500+ services (Gmail, Salesforce, Airtable, Slack, etc.)
* **Custom Integration**: Your own API connections for proprietary systems
* Execute actions like sending emails, creating records, retrieving data
* Handle data exchange with external systems
**See [Selecting Tools](/02-building-agents/agent-fundamentals/tools-integrations/tools-integrations) for comprehensive tool selection guidance.**
**See [Integration Connectors](/02-building-agents/agent-configuration/integration-connectors/integration-connectors) for detailed integration configuration guide.**
### Step 2: Adding Branches
**After every node, you can add branches** to create conditional logic and dynamic routing.
1. Click on the node you want to branch from
2. Select **"Add Branch"** or click the branch icon
3. A new branch path appears from the node
**Each branch requires unique edge selection criteria** that determines when this path should be taken.
**Edge Selection Criteria Types:**
**Condition-Based:**
* Data value comparisons (e.g., `priority == "high"`)
* Boolean checks (e.g., `order_exists == true`)
* String matching (e.g., `category contains "urgent"`)
* Numeric ranges (e.g., `order_total > 1000`)
**AI-Powered:**
* Semantic classification (e.g., "Route to sales if inquiry is about purchasing")
* Intent detection (e.g., "Branch to support if customer needs help")
* Content analysis (e.g., "Take urgent path if sentiment is negative")
**Example Configuration:**
```
Branch 1 Edge Criteria: priority == "high"
Branch 2 Edge Criteria: priority == "medium"
Branch 3 Edge Criteria: priority == "low"
```
1. Each branch leads to a different next node
2. Create new nodes or connect to existing ones
3. Each path follows its own execution logic
4. Branches can have different lengths and complexity
You can add multiple branches from the same node:
* Each branch must have **unique edge selection criteria**
* Criteria are evaluated in order
* First matching branch is taken
* Always include a fallback/default branch for unmatched cases
**Branch Types:**
**Conditional Paths:**
```
Classify Email Node →
├─ Branch 1: If category == "Sales" → Route to Sales Team
├─ Branch 2: If category == "Support" → Route to Support Team
└─ Branch 3: If category == "Billing" → Route to Billing Team
```
**Validation Branches:**
```
Check Order Exists Node →
├─ Branch 1: If order_found == true → Process Return
└─ Branch 2: If order_found == false → Request Order Number
```
**Priority Routing:**
```
Analyze Priority Node →
├─ Branch 1: If urgent == true → Immediate Processing
└─ Branch 2: If urgent == false → Standard Queue
```
### Step 3: Merging Branches
**Merging nodes** allow multiple branches to converge back into a single execution path.
Determine where parallel or conditional branches should rejoin:
**When to Use Merging:**
* After parallel processing that needs aggregation
* Combining results from multiple conditional paths
* Consolidating data from different sources
* Rejoining branches before final output
1. Add a new node where branches should converge
2. Connect multiple branch endpoints to this single node
3. Each execution follows one branch path at a time
4. Multiple executions can run simultaneously through different branches
**Understanding Branch Execution:**
* One execution = one branch path followed
* Multiple task executions can happen at the same time
* Each execution maintains its own state and data
* Merging occurs when different execution paths need to converge
After branches converge at a merge node:
* The node can access outputs from the branch path that led to it
* Link variables from previous nodes in the execution path
* Process data from the specific branch taken
* Continue execution with the context from that path
**Merge Examples:**
**Parallel Data Gathering:**
```
Start Node →
├─ Branch A: Fetch Customer Data →
├─ Branch B: Fetch Order History → Merge Node → Generate Report → End
└─ Branch C: Fetch Support Tickets →
```
**Conditional Paths Rejoining:**
```
Classification Node →
├─ Branch 1: If Urgent → Priority Processing →
└─ Branch 2: If Standard → Regular Processing → Merge Node → Send Notification → End
```
**Multi-Source Data Consolidation:**
```
Data Request Node →
├─ Branch A: Query Database →
├─ Branch B: Call External API →
└─ Branch C: Retrieve from Cache → Merge Node → Validate Combined Data → Return Results
```
### Step 4: Setting Exit Conditions
Define when and how the workflow should stop execution.
**Exit Points:**
* Flows end when they reach a node configured as an exit point
* You can have multiple exit points in one flow
* Each exit can return different output formats
* Configure output structure for each exit point
**Adding Exit Conditions:**
1. Add a node at any point in the flow
2. Mark it as an exit node
3. Configure the exit output schema
4. Connect from any node that should terminate there
**Common Exit Scenarios:**
* **Successful completion**: Task finished, return results
* **Manual review required**: Pause for human intervention
* **Error handling**: Graceful failure with error details
* **Early termination**: Conditions met, no further processing needed
## Next Steps
Choose and configure tools for your nodes
Configure variable fill methods and data flow between nodes
Configure external service connections and multi-connection patterns
Design JSON schemas for predictable tool outputs