┌─────────────────────────────────────────┐
│           NODE STRUCTURE                │
├─────────────────────────────────────────┤
│                                         │
│  INPUT        │                   OUTPUT│
│  HANDLES ────→│  [COMPUTATION]  ├────→ HANDLES
│               │                   │     
│  (LEFT SIDE)  │   (Process)      │ (RIGHT SIDE)
│               │                   │
└─────────────────────────────────────────┘

Properties:
✓ Receives typed inputs (left side)
✓ Performs single task (AI call, decision, data fetch)
✓ Produces typed outputs (right side)
✓ No state between executions (isolation)

Input Type System
├─ Text           (string, email, URL)
├─ Number         (integer, float, percentage)
├─ Boolean        (true/false)
├─ Object         (structured data with schema)
├─ Array          (list of items)
├─ File           (image, PDF, document)
└─ Enum           (predefined options)

Type Checking Rule:
Text output      → Text input        ALLOWED
Number output    → Text input        BLOCKED (type mismatch)
Object output    → Object input      ALLOWED (if schema matches)

CONNECTION VALIDATION

Valid Connections (enabled, clickable):
├─ Text output → Text input
├─ Number output → Number input
└─ Object {customer} → Object {customer} input

Invalid Connections (dimmed, blocked):
├─ Number output → Text input (cannot click)
├─ Array output → Object input (cannot click)
└─ File output → Text input (cannot click)

Hovering over handle shows:
"Expected type: Text"
"This output: Number"
"INCOMPATIBLE"

START NODES
├─ Start
│  └─ Output: user_input (any type user provides)
│
├─ Start
│  ├─ from (Text)
│  ├─ subject (Text)
│  ├─ body (Text)
│  └─ attachments (Array of Files)
│
├─ flow webhook on Start
│  └─ payload (Object: raw request data)
│
├─ Schedule Trigger
│  ├─ timestamp (Number)
│  └─ schedule_metadata (Object)
│
└─ Database Watch
   └─ record_changed (Object)

GENERATE TEXT NODE

Inputs:
├─ Model (Enum dropdown)
│  ├─ Claude Sonnet 4.5 (USD 3 per million input)
│  ├─ Claude Haiku 4.5 (USD 1 per million input)
│  ├─ GPT-4o (USD 2.50 per million input)
│  └─ Mistral Large (USD 2 per million input)
│
├─ Prompt (Text: your instruction)
│  └─ Can reference other outputs
│
├─ Temperature (Number: 0-2)
│  └─ 0 = deterministic, greater than 0 = creative
│
├─ Max Tokens (Number)
│  └─ Controls response length and cost
│
└─ System Prompt (Text: optional)
   └─ Instructions that apply to all calls

Outputs:
├─ Generated Text (Text)
│  └─ The AI response
│
├─ Token Count (Object)
│  ├─ input_tokens: 145
│  ├─ output_tokens: 287
│  └─ total_tokens: 432
│
└─ Cost (Number)
   └─ USD amount for this execution

AI call completes
Output: {response: "text"}
(cost hidden from flow)

AI call completes
Outputs: 
├─ text: "response"
├─ token_count: {input, output}
└─ cost: 0.003

You can use these in downstream logic:
"If cost greater than 0.01, send alert"
"Log token usage to database"

Syntax: {{nodeId.outputName}}

Examples:
├─ {{startNodeId.body}}
│  JSON body from a flow webhook, or a mapped start output
├─ {{generateTextNodeId.text}}
│  text output from Generate Text
└─ {{databaseNodeId.records}}
   array output; use the chip path UI for nested fields

Execution 1:
Input: "What is 2 plus 2?"
Model: Claude (temperature: 0)
Output: "4"

Execution 2 (same everything):
Input: "What is 2 plus 2?"
Model: Claude (temperature: 0)
Output: "4"

Execution 3 (change temperature to 0.7):
Input: "What is 2 plus 2?"
Model: Claude (temperature: 0.7)
Output: "The answer is four." ← different wording, same meaning

Each execution is ISOLATED.

Run 1: node outputs "Hello"
Run 2: node outputs "Hi" (different prompt)
Run 3: node outputs "Hello" (same as Run 1)

There is NO memory:
"Hey, I ran before and output Hello"

Each run starts fresh.

If you NEED memory (count visits, track status):
Use Database node to store and retrieve

During execution, a node has access to:

Automatic Access:
├─ Its own inputs
├─ Previous node outputs
├─ Environment variables (credentials, API keys)
├─ Execution metadata
│  ├─ run_id (unique ID for this execution)
│  ├─ timestamp (when it ran)
│  ├─ attempt_number (for retries)
│  └─ user_id (who triggered it)

All automatic. You do not manually configure.

Email Received
    ↓
AI Sentiment Analysis
    ├─ Score greater than 0.8 (happy customer)
    │  └─ Route to: Slack celebrations
    │
    ├─ Score 0.3 to 0.8 (neutral)
    │  └─ Route to: general-responses
    │
    └─ Score less than 0.3 (upset customer)
       └─ Route to: urgent-support
          ↓
       Alert manager and create ticket

If node checks: sentiment score greater than 0.8
├─ YES → Slack celebrations
└─ NO → Check next condition
   If score greater than 0.3
   ├─ YES → Slack general
   └─ NO → Priority support flow

Customer Email Arrives
    ↓
Three tasks RUN IN PARALLEL:

├─ Branch 1: AI sentiment analysis
│  └─ Executes: 2 seconds
│
├─ Branch 2: Database lookup (customer history)
│  └─ Executes: 300 milliseconds
│
└─ Branch 3: API call (inventory check)
   └─ Executes: 1.5 seconds

MERGE waits for slowest (2 seconds)
    ↓
All results available simultaneously
    ↓
Create comprehensive response

If serial (sequential):
└─ 2 seconds plus 0.3s plus 1.5s equals 3.8 seconds

If parallel (all together):
└─ maximum time equals 2 seconds
   Saves: 1.8 seconds per execution
   On 1,000 executions: 30 minutes saved

Batch Process 1,000 Customer Records
    ↓
Loop Node
├─ For each record:
│  ├─ AI analysis (2 seconds times 1,000 equals 33 mins)
│  ├─ Save result to database
│  └─ Count successes and failures
│
└─ Outputs per iteration:
   ├─ item (current record)
   ├─ index (1 to 1,000)
   └─ completed (when loop done)
    ↓
After loop: Summary
├─ Processed: 1,000 records
├─ Successful: 998
├─ Errors: 2
└─ Total cost: USD 15.40