The Pattern Builder is a visual editor for creating orchestration patterns using a drag-and-drop interface. Build complex multi-agent workflows without writing YAML.

Launch Pattern Builder

• Drag-and-drop interface - Create patterns visually
• Real-time YAML preview - See the generated configuration
• 15+ example patterns - Start from proven templates
• Export to YAML or Prism - Deploy anywhere
• Validation - Catch errors before deployment

flowchart LR
  subgraph UI["Pattern Builder UI"]
    Toolbar["Toolbar\nFile | Edit | Examples | Export | Help"]

    subgraph Workspace["Workspace"]
      Palette["Node Palette\nInput | Agent | Vote | Output"]

      subgraph Canvas["Canvas"]
        In["Input"] --> Agent["Agent"] --> Vote["Vote"] --> Out["Output"]
      end

      Preview["YAML Preview\nname: ...\nversion: ...\ninput: ..."]
    end
  end

  Palette --> Canvas
  Canvas --> Preview

Navigate to builder.parallaxai.dev or click "Pattern Builder" in the navigation.

Click Examples in the toolbar and select a template:

1. Drag an Input node onto the canvas
2. Drag an Agent node and connect it to the input
3. Add aggregation (Vote, Consensus, or Merge)
4. Add an Output node
5. Configure each node in the properties panel

Click any node to edit its properties:

• Input Node: Define input fields and types
• Agent Node: Set capabilities and count
• Aggregation Nodes: Configure strategy and thresholds
• Output Node: Map result variables

The YAML preview updates in real-time. When ready:

1. Click Export
2. Choose format (YAML or Prism)
3. Copy or download the configuration

• Pan: Hold Space and drag, or use scroll wheel + Shift
• Zoom: Scroll wheel, or use zoom controls in toolbar
• Fit: Press F or click "Fit" button

• Single: Click a node
• Multiple: Cmd/Ctrl + Click, or drag selection box
• All: Cmd/Ctrl + A

• Move: Drag selected nodes
• Connect: Drag from output handle to input handle
• Delete: Select and press Delete
• Duplicate: Cmd/Ctrl + D

Begin with the simplest pattern that could work:

1. Input → Agent → Output
2. Test it works
3. Add aggregation
4. Add validation
5. Add complexity as needed

The example patterns demonstrate best practices:

• Proper node connections
• Appropriate aggregation strategies
• Quality gate placement
• Output variable mapping

The builder shows validation errors:

• Red border: Missing required configuration
• Warning icon: Potential issues
• Error panel: Detailed error messages

Export and test your pattern at each stage:

# Test locally
parallax pattern validate my-pattern.yaml

# Dry run
parallax pattern execute my-pattern.yaml --dry-run

1. Drag Input node to canvas
2. Click to select
3. Add field: content with type string

1. Drag Agent node to canvas
2. Connect Input → Agent
3. Configure:
   • Capabilities: classification
   • Min agents: 3

1. Drag Vote node to canvas
2. Connect Agent → Vote
3. Configure:
   • Method: majority
   • Min votes: 2

1. Drag Output node to canvas
2. Connect Vote → Output
3. Map variables:
   • category: $vote.result
   • confidence: $vote.confidence

1. Click Export → YAML
2. Copy the generated YAML:

name: content-classifier
version: 1.0.0

input:
  content: string

agents:
  capabilities: [classification]
  min: 3

execution:
  strategy: parallel

aggregation:
  strategy: voting
  method: majority
  minVotes: 2

output:
  category: $vote.result
  confidence: $vote.confidence

• Verify compatible types (output → input)
• Check that the source node has an output handle
• Ensure the target node has an input handle

• Ensure at least Input and Output nodes exist
• Check for validation errors
• Verify all required fields are configured

• Read error messages in the error panel
• Check required node configurations
• Ensure all connections are complete

• Nodes - Detailed node reference
• Connections - Connection rules
• Exporting - Export formats and options