Sink

The Sink node terminates a workflow branch without taking any action. It's a "no-op" node that cleanly ends paths where no further processing is needed.

Overview

Configuration

The Sink node has no configuration parameters. It simply terminates the branch.

How It Works

[Process] ──▶ [Sink]
                │
                ✓ Branch ends cleanly

The Sink node:

1. Receives input data
2. Does nothing with it
3. Has no outputs
4. Branch execution is complete

Input Schema

Accepts any data from upstream. Data is consumed but not processed.

Output Schema

None—Sink has no outputs.

Examples

Basic Example: Handle False Branch

Terminate an If node's false path:

Workflow:

[If: needs_action?]
    ├── True ──▶ [Send Alert]
    └── False ─▶ [Sink]

Without Sink, the false branch would be disconnected, which is not recommended.

Example: Error Path Termination

End error paths that don't need handling:

Workflow:

[Load Meeting]
    ├── Success ──▶ [Process Data]
    └── Error ────▶ [Log Error] ──▶ [Sink]

The error is logged, then the branch ends.

Example: Filter Out Unwanted Items

Process only matching items, discard others:

Workflow:

[Select Many: items]
         │
         ▼
[If: meets_criteria?]
    ├── True ──▶ [Process Item]
    └── False ─▶ [Sink]

Items that don't meet criteria are simply discarded.

Example: Multi-Condition Filtering

Multiple levels of filtering:

Workflow:

[If: is_valid?]
    ├── True ──▶ [If: is_important?]
    │               ├── True ──▶ [Alert]
    │               └── False ─▶ [Sink] ← Not important enough
    │
    └── False ─▶ [Sink] ← Invalid, discard

Example: Handle No-Transcript Case

When transcript isn't available:

Workflow:

[Load Meeting]
       │
       ▼
[If: has_transcript?]
    ├── True ──▶ [AI: Analyze] ──▶ [Send Summary]
    │
    └── False ─▶ [Slack: "No transcript"] ──▶ [Sink]

Notify, then end without further processing.

Example: Duplicate Detection

Skip already-processed items:

Workflow:

[Load Item]
      │
      ▼
[If: already_processed?]
    ├── True ──▶ [Sink] ← Skip duplicate
    │
    └── False ─▶ [Process] ──▶ [Mark Processed]

Best Practices

1. Always Terminate Conditional Branches

Every If output should connect somewhere:

✅ Good:

[If]
├── True ──▶ [Action]
└── False ─▶ [Sink]

❌ Bad:

[If]
├── True ──▶ [Action]
└── False ─▶ (disconnected)

2. Use After Logging Errors

After logging an error, end cleanly:

[Error Path] ──▶ [Log Error] ──▶ [Sink]

Rather than leaving the log node's output unconnected.

3. Name Your Branches

Consider why each Sink exists:

// Filter: Not meeting our criteria
[If: criteria?]
    └── False ─▶ [Sink]

// Error: Failed to load data
[Load]
    └── Error ─▶ [Log] ──▶ [Sink]

4. Don't Over-Use

Sink is for intentional termination:

• ✅ Filtering unwanted items
• ✅ Graceful error handling
• ❌ Hiding problems (should address root cause)

Common Issues

Workflow seems incomplete

Symptom: Data enters Sink but expected processing doesn't happen

Cause: Logic error routing to Sink instead of processing

Solution:

1. Check If node conditions
2. Verify data meets criteria
3. Trace execution path in logs

"Why does my workflow do nothing?"

Symptom: Workflow completes but no actions taken

Cause: All paths leading to Sink

Solution:

1. Review If conditions—are they too restrictive?
2. Check if data matches expected format
3. Test with known-good data

Disconnected branches warning

Symptom: Visual warning about disconnected outputs

Cause: Output port not connected

Solution: Connect to Sink to explicitly terminate

Related Nodes

• If - Creates branches that may need Sink
• Any action node - For branches that should take action instead

Technical Details

Execution

Sink executes normally:

1. Receives input
2. Marks execution of this branch as complete
3. No further processing

Execution Status

Workflows with Sink-terminated branches:

• Can still complete successfully
• Sink doesn't indicate failure
• Just means "nothing more to do here"

Memory

Data sent to Sink is released:

• Not stored beyond execution logs
• No downstream processing
• Clean termination

Why Not Just Disconnect?

Using Sink instead of disconnected outputs:

1. Explicit intent: Shows termination is intentional
2. Clean graphs: No visual clutter from dangling connections
3. Execution clarity: Logs show clean branch completion
4. Best practice: Avoids ambiguity about whether disconnect was intentional

Comparison