Workflow Learning

Condition and router nodes can start with a natural language intent and progressively learn the correct expression from real execution data. Instead of writing precise expressions upfront, you describe what the node should do in plain language, and the system figures out the expression through repeated executions.

Why learning matters

Writing correct conditional expressions requires knowing the exact payload structure, field names, and value formats. This information isn't always available when building a workflow — especially for webhook-triggered workflows where the payload schema may be unfamiliar. Learning solves this by letting the AI interpret the intent against actual payloads and gradually converge on a deterministic expression.

Execution modes

Each condition and router node has an execution mode that controls how it evaluates:

Mode How it works
Static Uses a locked expression — no LLM call, deterministic
Learning AI interprets the intent against the payload, building confidence
Autonomous Always uses AI interpretation — for complex reasoning that can't be reduced to an expression

New nodes default to Learning mode. The goal is for most nodes to progress through learning and eventually lock into Static mode for fast, deterministic execution.

How learning works

A node in learning mode interprets your natural language intent against each incoming payload. As the system sees consistent results across multiple executions, it gains confidence in the expression and eventually locks it in for fast, deterministic evaluation without any LLM calls.

If the node's interpretations are inconsistent (e.g., payloads vary significantly), the system continues learning until it converges. Router nodes learn expressions for each route independently, and all routes must reach confidence before the router can be locked.

Drift detection

When a locked node encounters a payload whose structure differs from what it learned on, Thallus detects the change and flags it. You can resolve drift by providing a new expression manually or resetting the node to learning mode to adapt to the new payload format.

When to use each mode

Scenario Recommended mode
Payload structure is known and stable Static — write the expression directly
Payload structure is unknown or evolving Learning — let the system figure it out
Logic requires nuanced reasoning beyond simple expressions Autonomous — always use AI interpretation
Webhook from a new integration you haven't used before Learning — discovers the schema automatically
High-frequency workflow where speed matters Static — lock expressions for instant evaluation