CEL Expressions Reference

Reliant workflows use CEL (Common Expression Language) for dynamic values. CEL is a simple, safe expression language that allows you to reference data, perform calculations, and make decisions within your workflow YAML.

Overview

In Reliant workflows, all string values in YAML are treated as potential CEL expressions. The template syntax {{expression}} is used to embed CEL expressions within strings.

Key Concepts

Template Interpolation: Use {{expression}} to insert dynamic values into strings
Pure Expressions: When an entire value is {{expression}}, the native type is preserved (not converted to string)
Literal Strings: Text without {{}} is treated as a literal value
Explicit Namespaces: All data access uses explicit namespaces (inputs.*, nodes.*, etc.)

Quick Examples

# Simple value interpolation
model: "{{inputs.model}}"

# Literal string (no interpolation)
role: user

# String with embedded expression
content: "Processing iteration {{iter.iteration + 1}}"

# Conditional expression (ternary)
model: "{{inputs.model.id != '' ? inputs.model : {'tags': ['moderate']}}}"

# Accessing node outputs
tool_calls: "{{nodes.call_llm.tool_calls}}"

Template Syntax

Basic Interpolation

Use double curly braces to embed expressions within strings:

content: "Hello, {{inputs.username}}!"

Multiple expressions can appear in a single string:

content: "Running iteration {{iter.iteration + 1}} with exit code {{outputs.exit_code}}"

Type Preservation

When an entire YAML value is a single {{expression}}, the expression’s native type is preserved:

# Returns array (native type preserved)
tool_calls: "{{nodes.call_llm.tool_calls}}"

# Returns integer (native type preserved)
max_turns: "{{inputs.max_turns}}"

# Returns string (interpolation converts to string)
message: "You have {{nodes.count.value}} items"

Literal Values

Text without {{}} is passed through as-is:

role: user
type: call_llm
content: This is a literal string with no expressions

Template Rules

A {{ }} is read as CEL, not as text between braces, so these all work:

# Braces inside a string literal are data
is_json: "{{ nodes.run.stdout.startsWith('{') }}"
closes:  "{{ inputs.s.contains('}}') }}"

# A newline inside {{ }} is whitespace, in a folded (>-) or literal (|) scalar
label: >-
  {{ inputs.kind
     + '-' + inputs.name }}

# To write a literal {{ in text, make it an expression
note: "use {{ '{{' }} to open a template"

A {{ that never closes, an empty {{ }}, and an expression that does not parse are validation errors with the field path and the line and column inside the value. They are never treated as literal text: the runtime fails the node rather than send the source of the template to a model or a shell.

nodes.[0](a).system_prompt: "{{" has no closing "}}" (an unbalanced { or an unclosed string
inside the expression hides it) (line 1, column 7)

Raw-CEL fields (condition, while, a trigger filter) are not templates: write them without {{ }}. A {{ inside a string literal there is data.

Available Namespaces

Reliant uses an explicit namespace model—all data access must use a namespace prefix. There is no implicit variable injection.

inputs.*

Accesses workflow input parameters defined in the workflow schema.

inputs:
  model:
    type: model
    default: ""
  temperature:
    type: number
    default: 1.0
  mode:
    type: enum
    enum: ["manual", "auto", "plan"]
    default: "auto"

nodes:
  - id: call_llm
    type: call_llm
    args:
      model: "{{inputs.model}}"
      temperature: "{{inputs.temperature}}"

Common patterns:

# Direct access
"{{inputs.model}}"

# With default fallback
"{{inputs.model != '' ? inputs.model : 'claude-4.5-sonnet'}}"

# Checking mode inputs
"{{inputs.mode == 'auto'}}"

# Accessing grouped inputs
"{{inputs.Implementer.temperature}}"

nodes.*

Accesses outputs from completed workflow nodes. Only available after the referenced node has completed.

# Access a node's output field
"{{nodes.call_llm.response_text}}"

# Access nested fields
"{{nodes.call_llm.message.role}}"

# Access tool calls array
"{{nodes.call_llm.tool_calls}}"

# Check if a node completed with specific value
condition: nodes.run_tests.exit_code == 0

Optional Chaining (`?.`) for Conditional Nodes

When accessing nodes that may have been skipped (due to a condition: on the node), use optional chaining to safely handle the case where the node output doesn’t exist:

# Regular access - errors if node was skipped
"{{nodes.conditional_node.result}}"

# Optional chaining - returns optional.none() if node was skipped
"{{nodes.?conditional_node.result}}"

# With a default fallback value
"{{nodes.?conditional_node.result.orValue('default')}}"

# Check if node ran before accessing
condition: has(nodes.conditional_node)

Common CallLLM outputs:

Field	Type	Description
`message.role`	string	Always `"assistant"`
`message.text`	string	Response text content
`response_text`	string	Same as `message.text`
`tool_calls`	array	Tool calls requested by model
`token_count`	int	Total tokens the call used: input, output and cached
`response_data`	map	The parsed input of a `response_tool` call, when the node has one
`cost`	double	The call’s cost in USD, when the provider reports it
`compaction_threshold`	int	The token count at which the thread should be compacted for this model
`pending_inbox`	bool	Messages are queued for this thread, so an agent loop should take another turn
`stop_reason`	string	Why the turn ended — the field loop conditions should read
`finish_reason`	string	The raw provider stop reason behind `stop_reason` (escape hatch)

stop_reason values (a closed set — a new provider stop reason maps into one of these, never adds an eighth):

Value	Description	Typical agent-loop response
`tool_use`	The model requested tools	Continue — run them
`incomplete`	The provider paused the turn and expects it handed back (OpenAI `end_turn: false`, Anthropic `pause_turn`), and the turn produced text	Continue
`truncated`	Hit the output-token limit mid-turn	Continue (tool-presence loop) / stop (sentinel loop)
`interrupted`	The stream was cut short before the provider finished	Continue
`refused`	The safety system declined	Stop
`error`	Provider or transport failure, or an unrecognized reason	Stop
`done`	The model finished on its own terms	Stop

# An agent loop: continue while the model has more to do
while: "outputs.stop_reason in ['tool_use', 'incomplete', 'truncated', 'interrupted'] || outputs.pending_inbox == true"

Common Run outputs (shell commands):

Field	Type	Description
`exit_code`	int	Command exit code (0 = success)
`stdout`	string	Standard output
`stderr`	string	Standard error

Loop outputs: Loop outputs contain the last iteration’s sub-workflow outputs directly. Access them via nodes.<loop_id>.<output_name> where <output_name> matches outputs declared in the loop’s inline workflow. nodes.<loop_id>._iterations is the number of iterations that ran; a parallel loop also has _results (each iteration’s outputs, by key), _completed and _failed.

workflow.*

Provides workflow metadata and execution context.

Field	Type	Description
`workflow.id`	string	Unique workflow execution ID
`workflow.name`	string	Workflow definition name
`workflow.run_id`	string	Temporal run ID of the current execution
`workflow.mode`	string	Execution mode (`auto`, `manual`, `plan`), from `inputs.mode`
`workflow.path`	string	Absolute working directory of the current scope: the chat’s worktree or project, or a sub-workflow’s `project.path`
`workflow.worktree_path`	string	The chat’s worktree, when the current scope runs in it. Empty in the project’s main checkout
`workflow.branch`	string	That worktree’s git branch. Empty in the project’s main checkout, whose branch is not tracked

workflow.path is never rendered as an empty string. In a run with no project directory, reading it fails the node, the same way reading a missing key does. Test for it with has(workflow.path) where such a run is expected.

# Create unique resource names
name: "worktree-{{workflow.id}}"

# Include workflow context in messages
content: "Workflow {{workflow.name}} finished in {{workflow.path}}"

# Branch from the chat's worktree branch, or from the checkout's current commit
base_branch: "{{has(workflow.branch) ? workflow.branch : 'HEAD'}}"

Empty values in `run` commands

A run node fails before anything is sent to the machine if any plain value reference in its command renders empty. Plain references are things like {{workflow.path}}, {{inputs.dir}} and {{nodes.x.path}}. An empty value in a shell command changes what the command does: rm -rf "{{inputs.dir}}/" with an empty dir becomes rm -rf "/". When a value is genuinely optional, write an expression that says what empty means, for example {{has(inputs.flags) ? inputs.flags : ''}}.

failure.*

What failed, for the nodes of a workflow’s on_failure handler and nowhere else: the namespace is undeclared in the main graph, so failure there is a compile error.

Field	Type	Description
`failure.node_id`	string	The node that failed; empty when the run failed outside any node
`failure.node_path`	string	Its dotted path through loops and sub-workflows (`loop.body.node`)
`failure.error`	string	The failure as one line
`failure.error_code`	string	`node_error`, `outcome` (the graph reached an `outcome: failure` node) or `panic`
`failure.attempt`	int	The loop iteration the node was in, 1-based; 1 outside a loop

All five are always present, so a handler never fails reporting a failure. Reads of the main graph’s nodes.* inside the handler must be guarded (has() or .?): the nodes after the failed one never ran.

trigger.*

The event that started the run, fixed at launch. Also the only namespace a trigger’s filter, origin_filter, inputs and prompt can read. A chat started by a person has trigger.kind of chat.start.

Field	Type	Description
`trigger.kind`	string	What fired the run: `integration`, `webhook`, `schedule`, `workflow_event` or `chat.start`
`trigger.trigger_id`, `trigger.event_id`	string	The activation and the recorded event
`trigger.occurred_at`, `trigger.scheduled_for`	string	RFC 3339 time of the event; the slot a schedule fired for
`trigger.name`	string	The trigger’s name
`trigger.payload.*`	dynamic	The event’s data. Untrusted input
`trigger.sender.{kind,id,display_name,verified}`	string, bool	Who sent the event, as its source authenticated it
`trigger.activation.{id,params,owner.user_id,owner.github_id}`	string, map	The activation the event fires for: its id, its values for the workflow’s inputs, and its owner. Only in a trigger’s `filter`, `inputs`, `prompt` and `dedupe_key` (see Automations)
`trigger.origin.*`	see below	Whether Reliant caused the event, and which run did

trigger.origin has eight fields, all always present, so an expression never fails with “no such key”. An event nothing attributed reads caused_by_reliant: false, confidence: 'none', empty strings, same_workflow: false and lineage_depth: 0.

Field	Type	Description
`trigger.origin.caused_by_reliant`	bool	Reliant wrote the thing the event reports, at any confidence
`trigger.origin.confidence`	string	`exact`, `intent`, `app`, `claimed` or `none`
`trigger.origin.run_id`	string	The run that made the write. Empty unless it is the trigger owner’s own run
`trigger.origin.workflow`	string	That run’s workflow. Same rule
`trigger.origin.trigger_name`	string	The declared trigger that launched that run
`trigger.origin.same_workflow`	bool	That run is a run of the trigger’s own workflow: the event is its own echo
`trigger.origin.actor`	string	`app`, `owner` or `unknown`
`trigger.origin.lineage_depth`	int	Event-driven hops that led to the run that wrote. Capped at 5

# Ignore this workflow's own echoes (the default origin_filter)
origin_filter: "!(trigger.origin.same_workflow && trigger.origin.confidence in ['exact', 'intent'])"

# Hear everything
origin_filter: "true"

# Ignore this workflow's own echoes except one deliberate re-trigger
origin_filter: "!trigger.origin.same_workflow || trigger.origin.trigger_name == 'responder-push'"

# Only act on events a person caused
filter: "!trigger.origin.caused_by_reliant && trigger.sender.verified"

origin_filter is evaluated before filter, in the same language and over the same root. See Automations for what each confidence means and how skipped events are recorded.

iter.*

Provides loop iteration context. Only available inside loop constructs.

Field	Type	Description
`iter.iteration`	int	Current iteration (0-indexed in loop body; increments before while check)
`iter.item`	dynamic	The current element, in a loop with `items` (for a map, its value)
`iter.index`	int	The current element’s position, in a loop with `items`
`iter.key`	string	The current key, in a loop over a map

# Display human-readable iteration number
content: "Attempt {{iter.iteration + 1}}"

# Use in loop while condition (outputs.* contains current iteration's results)
while: outputs.exit_code != 0 && iter.iteration < 5

Note: Previous iteration data is available via outputs.* in while conditions. For inject templates, use thread: mode: inherit to preserve context across iterations.

output.*

Used in save_message blocks to reference the current activity’s output.

- id: call_llm
  type: call_llm
  save_message:
    role: "{{output.message.role}}"
    content: "{{output.message.text}}"
    tool_calls: "{{output.tool_calls}}"

Note: Token counts (input_tokens, output_tokens, etc.) and thinking are automatically extracted from activity output - no explicit configuration needed.

outputs.*

Used in loop while conditions to reference the sub-workflow’s declared outputs.

- id: retry
  type: loop
  while: outputs.exit_code != 0 && iter.iteration < 10
  inline:
    outputs:
      exit_code: "{{nodes.verify.exit_code}}"

Built-in Functions

Standard CEL Functions

Function	Description	Example
`size(x)`	Length of list, map, or string	`size(nodes.call_llm.tool_calls) > 0`
`has(x.field)`	Check if field exists	`has(nodes.verify) ? nodes.verify.exit_code == 0 : true`
`type(x)`	Get type of value (compare with a type name, not a string)	`type(inputs.data) == string`

String Functions

Function	Description	Example
`s.contains(substr)`	Check if string contains substring	`output.stderr.contains("error")`
`s.startsWith(prefix)`	Check if string starts with prefix	`inputs.model.startsWith("claude")`
`s.endsWith(suffix)`	Check if string ends with suffix	`inputs.file.endsWith(".go")`
`s.trimPrefix(prefix)`	Remove a leading prefix when present	`nodes.run.stdout.trimPrefix("Error: ")`
`s.trimSuffix(suffix)`	Remove a trailing suffix when present	`nodes.run.stdout.trimSuffix("\n")`
`s.matches(pattern)`	Regex match	`output.stdout.matches("^OK")`

These are member functions: write s.contains(x), not contains(s, x). The full string, list, set, math and regex function set is in the function reference above.

Reliant Custom Functions

`first(list)`

Returns the first element of a list as an optional. Returns optional.none() if the list is empty. Use .orValue(default) to unwrap with a default value, or .value() to unwrap (errors on empty).

# Get first tool call, or null if none
first_tool: "{{nodes.call_llm.tool_calls.first().orValue(null)}}"

# Direct access (will error on empty list)
first_tool: "{{nodes.call_llm.tool_calls.first().value()}}"

`last(list)`

Returns the last element of a list as an optional. Returns optional.none() if the list is empty. Use .orValue(default) to unwrap with a default value, or .value() to unwrap (errors on empty).

# Get last tool call, or null if none
last_tool: "{{nodes.call_llm.tool_calls.last().orValue(null)}}"

`join(list, delimiter)`

Joins list elements into a string with a delimiter.

# Join array elements
tools_list: "{{inputs.tools.join(',')}}"

`parseJson(string)`

Parses a JSON string into a CEL value (map or list).

data: "{{parseJson(nodes.fetch.body)}}"

`toJson(value)`

Converts a value to its JSON string representation.

# As global function
json_str: "{{toJson(nodes.call_llm.tool_calls)}}"

# As member function
json_str: "{{nodes.call_llm.tool_calls.toJson()}}"

`coalesce(value1, value2, ...)`

Returns the first non-null argument. Supports 2-4 arguments.

# Use default if input is null
model: "{{coalesce(inputs.model, {'tags': ['moderate']})}}"

# Chain multiple fallbacks
value: "{{coalesce(inputs.primary, inputs.secondary, 'default')}}"

`getOrDefault(map, key, default)`

Safely accesses a map key with a fallback default value.

name: "{{getOrDefault(inputs, 'name', 'unnamed')}}"

`spawn(workflowRef, presets)`

Generates a tool filter entry for spawning sub-agents. Used within tool_filter CEL expressions.

# Enable spawn with specific presets
tool_filter: "{{inputs.tools + [spawn(workflow.name, inputs.spawn_presets)]}}"

# Disable spawn by passing empty presets
tool_filter: "{{inputs.tools + [spawn(workflow.name, [])]}}"

Returns a filter string like spawn:builtin://agent(general,researcher). If the presets list is empty, returns an empty string (effectively disabling spawn).

Standard Libraries

Every workflow expression, in the runtime, in validation and in trigger filters, has the CEL standard library plus these extensions:

Library	What it adds
Strings	`trimPrefix`, `trimSuffix`, `split`, `join`, `replace`, `format`, `lowerAscii`, `upperAscii`, `trim`, `indexOf`, `substring`, `padLeft`, `padRight`
Lists	`sort()`, `sortBy(x, key)`, `distinct()`, `flatten()`, `slice(a, b)`, `first()`, `last()`, `lists.range(n)` (at most 100,000)
Sets	`sets.contains(a, b)`, `sets.intersects(a, b)`, `sets.equivalent(a, b)`
Math	`math.greatest(...)`, `math.least(...)`, `math.abs`, `math.ceil`, `math.floor`, `math.round`, `math.sign`
Encoders	`base64.encode(bytes)`, `base64.decode(string)`
Bindings	`cel.bind(name, value, body)`: name an intermediate value once
Regex	`regex.extract`, `regex.extractAll`, `regex.replace` (plus `string.matches(re)` from the standard library)
Two-variable comprehensions	`m.all(k, v, ...)`, `m.exists(k, v, ...)`, `m.transformMap(k, v, ...)`
Optional types	`x.?field`, `x[?key]`, `.orValue(d)`, `.hasValue()`, `.value()`
Timestamps and durations	`timestamp('2026-10-14T03:00:00Z')`, `duration('45m')`, `ts + dur`, `ts1 - ts2`, `ts < ts2`, `ts.getHours()`, `dur.getMinutes()`

Evaluation is cost-bounded: one expression may do at most 1,000,000 units of work (about one per operation or per element a comprehension visits), and parseJson, json.decode and toJson are charged by the size of their text. An expression over the limit fails with cost limit exceeded; narrow the data it loops over.

`json.decode(string)`

Parses JSON without failing: the value as an optional, or optional.none() when the text is empty or is not exactly one JSON value. Use it on a node’s stdout, which is often “not JSON yet” when a tool printed an error. parseJson is the strict form: bad input fails the step. Both keep JSON integers as integers (225976313 stays 225976313, not 2.25976313e+08), and both refuse text over 8 MiB.

status: "{{ json.decode(nodes.start.stdout).?status.orValue('error') }}"

Logic a script usually carries

These replace the data logic of a bash helper in a workflow, as a compute node’s outputs or in a condition. Each is tested (internal/workflow/cel/helper_logic_test.go).

Need	Expression
Has a label	`'agent:ready' in inputs.labels`
Has any of several	`sets.intersects(inputs.labels, ['skip-review', 'wip'])`
Text carries our marker	`inputs.body.contains('<!-- autopilot')`
Valid repo from an allowlist	`['org/a', 'org/b'].exists(r, r == inputs.repo)`
Positive integer id	`inputs.num.matches('^[1-9][0-9]{0,9}$')`
Safe run id (no shell characters)	`inputs.run.matches('^[A-Za-z0-9._:-]{1,128}$')`
Hex fingerprint	`inputs.fp.matches('^[0-9a-fA-F]{6,64}$')`
Lease still live	`timestamp(inputs.expires) > timestamp(now())`
Lease expiry, TTL from now	`string(timestamp(now()) + duration('45m'))`
Minutes left on a lease	`int((timestamp(inputs.expires) - timestamp(now())).getMinutes())`
Expires within 15 minutes	`timestamp(inputs.expires) - timestamp(now()) < duration('15m')`
Read a JSON field, tolerantly	`json.decode(nodes.start.stdout).?status.orValue('error')`
Size label from additions + deletions	`inputs.adds + inputs.dels < 60 ? 'size:S' : (inputs.adds + inputs.dels < 400 ? 'size:M' : 'size:L')`
Map an alert’s service to a repo	`cel.bind(svc, inputs.service.lowerAscii(), svc.matches('^(reliant-)?(api-server\|temporal-worker\|daemon)$') ? 'org/reliant' : (svc.matches('^forge($\|[-_])') ? 'org/forge' : 'org/control-plane'))`
Earliest held lease (oldest, then lowest id)	`cel.bind(held, inputs.leases.filter(l, l.state == 'held'), cel.bind(first, held.map(l, l.created_at).sort()[0], held.filter(l, l.created_at == first).sortBy(l, l.id)[0].run))`
Earliest expiry among held leases	`inputs.leases.filter(l, l.state == 'held').map(l, timestamp(l.expires)).sort()[0]`

(In a markdown table the | of a regex alternation is escaped as \|; write a plain | in YAML.) Chain several of these in one compute node (see Nodes).

Testing an expression

Try an expression, a filter or an input mapping without running the workflow:

# A trigger filter against the payload GitHub declares for issues.opened
reliant workflow eval --integration github --event issues.opened --scope trigger \
  "!('wontfix' in trigger.payload.data.issue.labels)"

# Override just the fields the expression reads
reliant workflow eval --integration github --event issues.opened \
  --trigger-payload '{"data":{"issue":{"number":42}}}' "Triage #{{ trigger.payload.data.issue.number }}"

# Dry-run every declared trigger of a workflow against a sample event
reliant workflow validate triage.yaml --trigger-payload @event.json

It prints the value and its CEL type, or the error with its phase (syntax, compile, eval) and position. A read the integration’s declared payload rules out is reported too, because a filter that passes on a sample can still fail on a real event. Agents get the same thing as the cel_eval tool.

Response Tool Data Access

Response tool data is available directly on ExecuteTools output via the response_data field. This field contains parsed response data keyed by tool name. Response tools use JSON Schema to define structured outputs. A common pattern is choice/value:

response_tool:
  name: audit_result
  description: Report audit findings
  schema:
    type: object
    required: [choice, value]
    properties:
      choice:
        type: string
        enum: [approved, denied]
        description: |
          Choose one:
          - approved: Agent is on track
          - denied: Agent needs guidance
      value:
        type: string
        description: Explanation for your choice

Access the structured response via response_data:

# Check the choice
condition: nodes.execute_audit.response_data.audit_result.choice == 'approved'

# Access the value
guidance: "{{nodes.execute_audit.response_data.audit_result.value}}"

For more complex schemas, you can define arrays and nested objects:

response_tool:
  name: filtered_results
  description: Submit filtered tool results
  schema:
    type: object
    required: [results]
    properties:
      results:
        type: array
        items:
          type: object
          properties:
            tool_call_id: { type: string }
            content: { type: string }

`parseDuration(string)`

Parses a Go duration string and returns seconds as a number.

timeout_seconds: "{{parseDuration('5m')}}"    # Returns: 300
total_seconds: "{{parseDuration('1h30m')}}"   # Returns: 5400

Common Patterns

Conditional Logic

Use the ternary operator for conditional values:

# Simple conditional
model: "{{inputs.model.id != '' ? inputs.model : {'tags': ['moderate']}}}"

# Nested conditional
prompt: "{{inputs.mode == 'plan' ? inputs.planning_prompt : inputs.system_prompt}}"

# Multi-level conditional
prompt: |
  {{inputs.mode == 'plan' ? inputs.planning_prompt :
    inputs.mode == 'auto' ? inputs.auto_prompt :
    inputs.default_prompt}}

Default Values

Several patterns for handling missing or empty values:

# Ternary with empty string check
model: "{{inputs.model != '' ? inputs.model : 'default-model'}}"

# Using coalesce (for null values)
value: "{{coalesce(inputs.optional, 'fallback')}}"

# Using getOrDefault (for map access)
setting: "{{getOrDefault(inputs, 'setting', 'default')}}"

# Combining approaches
model: "{{inputs.Custom.model != '' ? inputs.Custom.model : coalesce(inputs.model, 'default')}}"

Checking Optional Fields

Use has() to safely check for optional fields:

# Check if node exists before accessing its output
condition: "has(nodes.verify) ? nodes.verify.exit_code == 0 : true"

# Check nested optional fields
branch: "{{has(workflow.branch) ? workflow.branch : 'HEAD'}}"

Working with Tool Calls

Common patterns for handling tool calls from LLM responses:

# Check if there are tool calls
condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0

# In edge conditions
edges:
  - from: call_llm
    cases:
      - to: execute_tools
        condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0
      - to: done
        label: "no_tools"

Loop Iteration Patterns

Using iteration context in loops:

# Display iteration number
content: "Attempt {{iter.iteration + 1}} of {{inputs.max_turns}}"

# Use in while condition to limit iterations
while: outputs.exit_code != 0 && iter.iteration < inputs.max_turns

String Interpolation

Embed multiple values in strings:

content: |
  ## Task Complete
  
  **Final iteration:** {{iter.iteration}}
  **Exit Code:** {{nodes.verify.exit_code}}

Type Handling

CEL Type System

CEL is strongly typed. Values have specific types that affect how operators and functions work.

Type	Description	Examples
`int`	Integer numbers	`0`, `42`, `-1`
`double`	Floating point	`1.5`, `0.0`, `-3.14`
`string`	Text	`"hello"`, `""`
`bool`	Boolean	`true`, `false`
`list`	Ordered collection	`[1, 2, 3]`, `[]`
`map`	Key-value pairs	`{"key": "value"}`
`null`	Null value	`null`

Null Checks

Always check for null before accessing nested fields:

# Safe null check pattern
condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0

# Using has() for optional fields
value: "{{has(nodes.optional_node) ? nodes.optional_node.result : 'default'}}"

# Coalesce for null handling
model: "{{coalesce(inputs.model, 'default')}}"

Type Coercion

CEL performs limited automatic type coercion:

# Numbers in string interpolation are converted to strings
content: "Count: {{nodes.count.value}}"  # int -> string

# Explicit string conversion if needed
str_value: "{{string(nodes.count.value)}}"

Boolean Evaluation

Values are not implicitly converted to booleans. Use explicit comparisons:

# Correct: explicit comparison
condition: nodes.run.exit_code == 0

# Correct: explicit null check
condition: nodes.call_llm.tool_calls != null

# Wrong: implicit boolean conversion (will error)
# condition: nodes.run.exit_code  # Don't do this

Edge Conditions

Edge conditions use CEL expressions without the {{}} wrapper:

edges:
  - from: call_llm
    cases:
      # Condition is a raw CEL expression (no {{}} needed)
      - to: execute_tools
        condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0
        label: "has_tools"
      
      # Combining multiple conditions
      - to: approval
        condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0 && inputs.mode == 'manual'
        label: "require_approval"
      
    # Every case needs a condition. Where to go when none matches:
    default: done

Loop While Conditions

Loops use do-while semantics: the first iteration always executes, then iter.iteration increments before the while condition is checked to determine whether to continue.

- id: retry_loop
  type: loop
  while: outputs.exit_code != 0 && iter.iteration < 10  # Continue while failing AND under 10 iterations
  inline:
    outputs:
      exit_code: "{{nodes.verify.exit_code}}"

Skipping the loop entirely: To conditionally skip a loop before it runs, use the node’s condition field:

- id: retry_loop
  type: loop
  condition: inputs.enable_retries == true  # Skip loop if retries disabled
  while: outputs.exit_code != 0 && iter.iteration < 5
  inline:
    # ...

Available namespaces in while:

outputs.* - Sub-workflow outputs defined in inline.outputs
iter.* - Loop iteration context (iter.iteration is 0-indexed)
inputs.* - Workflow inputs (useful for configurable iteration limits like inputs.max_turns)

Do-while behavior: The loop always runs at least once. After each iteration, iter.iteration increments, then the while condition is evaluated. Iteration counting: In the loop body, iter.iteration is 0-indexed (0, 1, 2…). In the while check, it reflects completed iterations (1 after first, 2 after second). Use iter.iteration < N to run exactly N iterations.

Common Mistakes

Missing Null Checks

# Wrong: will error if tool_calls is null
condition: size(nodes.call_llm.tool_calls) > 0

# Correct: check for null first
condition: nodes.call_llm.tool_calls != null && size(nodes.call_llm.tool_calls) > 0

Wrong Namespace

# Wrong: 'message' is not a top-level namespace
content: "{{message.content}}"

# Correct: use inputs for user-provided data
content: "{{inputs.task}}"

# Correct: use nodes.<id>.message for node outputs
content: "{{nodes.call_llm.message.text}}"

Using `{{}}` in Conditions

# Wrong: conditions are raw CEL; {{}} is a validation error
condition: "{{nodes.run.exit_code == 0}}"

# Correct: raw CEL expression in conditions
condition: nodes.run.exit_code == 0

Empty String vs Null

# Empty string is NOT null - coalesce won't help
model: "{{coalesce(inputs.model, 'default')}}"  # Returns "" if inputs.model is ""

# Use ternary for empty string check
model: "{{inputs.model != '' ? inputs.model : 'default'}}"

Accessing Undefined Nodes

# Wrong: node hasn't completed yet or doesn't exist
content: "{{nodes.nonexistent.value}}"

# Correct: use has() for optional nodes
content: "{{has(nodes.optional) ? nodes.optional.value : 'N/A'}}"

Debugging Tips

Check node IDs: Ensure referenced node IDs match exactly (case-sensitive)
Verify node completion: nodes.* only works after the node completes
Use has() liberally: Wrap optional field access in has() checks
Check types: Use type(x) to debug unexpected type errors
Start simple: Build complex expressions incrementally

​Overview

​Key Concepts

​Quick Examples

​Template Syntax

​Basic Interpolation

​Type Preservation

​Literal Values

​Template Rules

​Available Namespaces

​inputs.*

​nodes.*

​Optional Chaining (?.) for Conditional Nodes

​workflow.*

​Empty values in run commands

​failure.*

​trigger.*

​iter.*

​output.*

​outputs.*

​Built-in Functions

​Standard CEL Functions

​String Functions

​Reliant Custom Functions

​first(list)

​last(list)

​join(list, delimiter)

​parseJson(string)

​toJson(value)

​coalesce(value1, value2, ...)

​getOrDefault(map, key, default)

​spawn(workflowRef, presets)

​Standard Libraries

​json.decode(string)

​Logic a script usually carries

​Testing an expression

​Response Tool Data Access

​parseDuration(string)

​Common Patterns

​Conditional Logic

​Default Values

​Checking Optional Fields

​Working with Tool Calls

​Loop Iteration Patterns

​String Interpolation

​Type Handling

​CEL Type System

​Null Checks

​Type Coercion

​Boolean Evaluation

​Edge Conditions

​Loop While Conditions

​Common Mistakes

​Missing Null Checks

​Wrong Namespace

​Using {{}} in Conditions

​Empty String vs Null

​Accessing Undefined Nodes

​Debugging Tips

​See Also