Expressions

Expressions are the mechanism by which nodes communicate in a workflow. They're {{variable.field}} placeholders in node configuration fields that get resolved to actual values at execution time.

---

Expression Syntax

All expressions use double curly braces:

{{node_name.field}}

Expressions can appear in any text configuration field:

• Agent node's Input field
• Branch node's Condition field
• Loop node's Items Expression field
• Output node's Value field
• Human-in-Loop node's Display Value field

---

Trigger Expressions

Expression	Type	Description
{{trigger.output}}	string	The trigger's initial output — what started the workflow
{{trigger.<param>}}	any	A named trigger input parameter (Params trigger) — resolves from the value passed at run time, or the param's default value when none is given

This is the most-used expression. It appears in the first agent node's input to pass the workflow's entry point to the first agent.

{{trigger.<param>}} resolves the typed input parameters defined on a Params trigger (see Triggers → Params Trigger). On a manual/Bridge run with no explicit values, each param falls back to its configured default value, so design your defaults to keep {{trigger.<param>}} meaningful.

Examples by trigger type:

Trigger Type	{{trigger.output}} Value
Manual	The string typed in the run modal
Webhook	The webhook payload (or extracted field if payload_path set)
Schedule	The default_input value configured on the trigger
HTTP	The full request context as JSON string

---

Agent Node Expressions

Each agent node exposes its output via an expression based on the agent's name (not the node's canvas label).

Expression	Description
{{agent_name.output}}	The full text output from the agent

Important: The variable name is the agent's name as configured in the Agent Editor — not the display label you give the node on the canvas.

Example:

If you have an agent named researcher (configured in Agents → the agent's name field) and you place it in a workflow node labeled "Step 1: Research", the expression is:

{{researcher.output}}  ✅ Correct (agent name)
{{step-1-research.output}}  ❌ Wrong (node label)

Referencing Previous Agents

You can reference any upstream agent's output in any downstream node, not just the immediately preceding node:

Research summary from {{researcher.output}}

Writer's draft: {{writer.output}}

Please review both and produce a final version.

All previously executed nodes' outputs are available throughout the workflow.

---

Loop Node Expressions

Loop nodes provide two special variables accessible within the loop body:

Expression	Type	Description
{{loop_name.current_item}}	string	The current item being processed in this iteration
{{loop_name.index}}	int	The 0-based index of the current iteration
{{loop_name.output}}	string	After loop completes: JSON array of all iteration results

Example — loop named content_loop:

# In a downstream agent's Input field:
Process item number {{content_loop.index}} (0-based).
Current item to analyze: {{content_loop.current_item}}

# After loop completes, in an Output node:
All processed items: {{content_loop.output}}

The output after a loop is a JSON array:

["result for item 1", "result for item 2", "result for item 3"]

---

Branch Node Expressions

Expression	Description
{{branch_name.output}}	"True" or "False" (string representation of the condition result)

This is rarely used in text fields, but is available for debugging or passing branch decisions downstream.

---

Human-in-Loop Expressions

Expression	Description
{{hil_name.output}}	"approved" or "rejected" + any reviewer comment

Example output format: "approved" or "rejected: The code quality is insufficient, please revise the error handling"

---

Expression in Context: Examples

Simple Pipeline

Trigger input: "Write a blog post about quantum computing"

Agent node (writer agent) Input:
  {{trigger.output}}
  → Resolves to: "Write a blog post about quantum computing"

Output node Value:
  {{writer.output}}
  → Resolves to: "## Quantum Computing: The Future is Now\n\n..."

Multi-Agent Pipeline

Trigger input: "quantum computing for enterprise"

Researcher agent Input:
  Research this topic thoroughly: {{trigger.output}}
  
Writer agent Input:
  Research findings:
  {{researcher.output}}
  
  Please write a 500-word blog post based on these findings.
  Topic: {{trigger.output}}
  
Editor agent Input:
  Please edit and improve this draft:
  {{writer.output}}
  
  Original research brief:
  {{researcher.output}}

Loop with Context

Loop items: ["Python", "JavaScript", "Rust", "Go"]
Loop name: lang_loop

Agent inside loop Input:
  Write a one-paragraph introduction to {{lang_loop.current_item}}.
  This is language {{lang_loop.index}} of 4 in our comparison series.

Output after loop:
  Here are all the language introductions:
  {{lang_loop.output}}

Conditional with Dynamic Content

Branch condition:
  len(str(output)) > 1000

True path agent (summarizer) Input:
  This content is long ({{researcher.output | length}} chars).
  Please summarize it to under 200 words:
  {{researcher.output}}

False path agent Input:
  This content is short. Simply clean up and format:
  {{researcher.output}}

---

Expression Resolution Rules

1. Execution order matters: You can only reference nodes that have already completed. Referencing a downstream node returns empty string.

2. Case sensitivity: {{researcher.output}} ≠ {{Researcher.output}}. Agent names are case-sensitive.

3. Unresolved expressions: If an expression references a node that doesn't exist or hasn't run, it resolves to an empty string "" (not an error).

4. Nested quotes: Expressions work inside strings. The entire field value is processed, replacing {{...}} patterns.

5. JSON inside expressions: If an agent's output is JSON, the entire JSON string is substituted. To extract a specific field, use a Transform node (see below).

---

Working with JSON Outputs

If an upstream agent outputs JSON:

{"severity": "high", "count": 42, "details": "..."}

The expression system substitutes the whole value — it doesn't do field access like {{analyzer.output.severity}}.

Solution: add a Transform node. The Transform node extracts fields with JSONPath (no code execution involved):

Transform node
  Input:     {{analyzer.output}}
  JSONPath:  $.severity
  Output:    "high"

Downstream nodes then reference the extracted value via {{transform.output}}. See Node Types → Transform and the Expression Reference.

---

Expression Reference Table

See Expression Reference for the complete reference table of all variables across all node types.

---

Debugging Expressions

Problem: Expression shows literally (not resolved)

Symptom: Downstream node shows {{researcher.output}} as literal text.

Causes:

1. The upstream agent failed — so its output is empty/null
2. Typo in the agent name (check exact spelling in the Agents list)
3. The node is not connected — output never ran

Debug steps:

1. Check the execution details — was the upstream node green (complete)?
2. Verify the agent name matches exactly

Problem: Wrong value injected

Symptom: Correct expression, but unexpected value.

Likely cause: The agent name is shared — two agents with similar names, or the wrong agent is selected in the node.

Debug steps:

1. Open execution details → check the node's input field (shows fully resolved value)
2. Verify the node's selected agent in the inspector

Problem: JSON formatting breaks

Symptom: Expression inside a JSON string causes parse errors.

Cause: The resolved value contains quotes or newlines that break JSON syntax.

Solution: Don't embed expressions directly inside JSON strings in configuration fields. Instead, have an agent produce the final JSON as its output, or use a Transform node to shape the data.