Step types
The editor offers thirteen step types, grouped into four families in the palette. This page describes each one: what it is for, how it is used, what it produces, and where it stops.
The thirteen at a glance
| Family | In the palette | What it is for |
|---|---|---|
| Data | Call an API | Calling an external system over HTTP |
| Data | Reshape data | Rearranging data you already have, without calling anything |
| Data | Query corporate data | Reading governed data from Infinite Data |
| Data | Run an automation | Running a published program, with declared inputs and outputs |
| Data | Prepare data | Assembling an object field by field for the next step |
| Intelligence | Generate with a model | Sending text to a model and getting the answer back |
| Intelligence | AI task | Delegating a task that needs judgment and tools |
| Control | Condition | Taking the "Yes" or "No" path based on a comparison |
| Control | Choose a path | Taking one of several named paths |
| Control | Combine results | Merging what came from several paths |
| Control | For each item | Repeating the same treatment for each item in a list |
| Control | Wait | Pausing for a duration or until a date |
| Control | Human approval | Pausing until someone approves or rejects |
| Control | Call another agent | Running another published agent and using its result |
| Output | Result | Ending the run with the final output |
It is a connection. Every step that can fail has an "If it fails" exit — connecting it to another step diverts the flow. See The error path is not a step.
Three things that hold for all of them
Data from other steps is picked, not typed. Where a field accepts a dynamic value, you use the Data button to choose the source: a field from what triggered the run, the output of an earlier step, or information about the run itself. The step you choose has to run before this one — the editor refuses a forward reference. See Data between steps.
Deterministic or not. The Data and Control steps give the same result for the same input. The Intelligence ones do not — the same question can produce different answers. That changes how you test and what you promise the agent's users.
Only what the space allows gets in. The palette shows the types, but what each step can reach — addresses, actions, AI resources, skills — depends on what the space allows. See Allowed resources.
Data
Deterministic steps: Agents itself runs them, with no AI in between.
Call an API
What it is for. Integrating with any system that speaks HTTP — opening a ticket, fetching a record, firing a third party's webhook.
How to use it. Choose the method, enter the address, and fill in parameters, headers, and body. If the system requires a credential, use the Authentication section — the credential becomes a space secret and the agent keeps only the reference. The address has to be on the space's allowed list, or publishing is refused.
Produces. The HTTP code, the JSON body, the text body, the headers, and whether the response was truncated.
Where it stops. A 30-second timeout by default, up to 120. A response above 1 MiB comes back truncated and marked. Up to 3 redirects.
Its own page: Calling an API.
Reshape data
What it is for. Rearranging data you already have — renaming fields, grouping, flattening a structure — without calling any system.
How to use it. Assemble the object by choosing, for each field, where the value comes from. That is all: there is no address, no credential, no code.
Produces. Exactly the object you assembled.
When to prefer this over "Prepare data". Both assemble an object and neither calls anything. Use Reshape data when the rearranging is part of the integration sequence, alongside the other actions; use Prepare data when it is just a tidying step between two others. If in doubt, either will do.
Query corporate data
What it is for. Reading governed data from Infinite Data inside a flow — a balance, a history, a customer list — without exporting anything.
How to use it. Choose the action: run a query, or explore the catalog (list catalogs, schemas, tables, describe a table). To query, write the SQL. The query is read-only.
Who sees what. The query runs with the identity of whoever triggered the run, not with a service account. Someone without access to a table in Infinite Data still has no access to it through the agent — the permissions are the same on both sides.
Produces. The rows, the columns, the count, whether the result was truncated, and the query's identifier.
Because it uses the requester's identity, an agent with this step does not work when triggered by a schedule or an endpoint — in those cases there is no person, and the step fails rather than picking an identity on its own. Agents with corporate data queries are triggered by people.
Its own page: Querying corporate data.
Run an automation
What it is for. Running a published automation — a versioned program with declared inputs and outputs — when the task is deterministic and has to be identical every time: syncing a record, switching on a resource, applying a routine.
How to use it. Choose the automation and the exact version (never "the latest"), fill in the inputs, and decide what happens if it fails: stop the run or take the error path.
There is no command, script, or shell field — and that absence is deliberate. You choose an automation someone published and the organization adopted; you do not write code inside the agent.
Produces. The automation's output, whether anything changed, how long it took, and which version ran.
Where it stops. The effective timeout is the smallest of the step's, the automation's, and the organization's.
When to prefer this over "Call an API". An HTTP query is one request. If the integration requires authenticating, paginating, and handling specific errors, that is a procedure — and a procedure is an automation. Neither uses AI.
Prepare data
What it is for. Assembling the final value field by field, usually before the Result, or preparing the next step's input: joining two fields, renaming, pinning a value.
How to use it. For each field in the object, choose where the value comes from. It runs no code.
Produces. Exactly the object you assembled.
Intelligence
The two steps that use models. Choosing between them is the most consequential decision in the editor.
The difference that decides
| Generate with a model | AI task | |
|---|---|---|
| What it is | One question, one answer | A task, with iteration |
| Uses tools | No | Yes, the allowed ones |
| Opens or produces files | No | Yes |
| Cost and predictability | Lower, more predictable | Higher, variable |
| Requires a service account | No | Yes |
Anyone who needs a tool or a file uses AI task. Anyone who just needs to turn text into text uses Generate with a model — it is cheaper and more predictable.
Generate with a model
What it is for. Writing, summarizing, classifying, translating, or extracting — tasks where the answer is the text.
How to use it.
| Field | Use |
|---|---|
| Model | One of the available models |
| What to ask the model | The request, with data from earlier steps via the "Data" button |
| How the model should behave | Optional. It applies to the whole answer |
| Answer format | Free text, or fields to use in other steps |
| Maximum size | If the answer hits the limit, the step fails rather than delivering truncated text |
| Creativity | From predictable to more varied |
Produces. The generated text, the model used, the stop reason, and the tokens consumed.
An ambiguous answer may already have been billed, and retrying automatically would bill again. If you need another attempt, it is explicit.
AI task
What it is for. Delegating a task that needs judgment on every run and the use of tools — analyzing a set of documents, investigating a case, producing a report.
How to use it. Write the objective the way you would ask a person. Then decide what it may use: no tools, a chosen list, or everything the space allows. Declare what it has to return.
Three fields prevent most problems:
- Required tools — the step fails before spending the model if any are unavailable.
- Must produce a file — the step fails if the promised file is not actually saved.
- Answer format — declares the expected fields, which then become verifiable.
A step with none of the three is unverifiable: it always "finishes", and nobody can say whether it did the work. Publishing warns when that happens.
Produces. The text, the session identifier, how many tools it used, and the declared fields.
Requires. A service account configured in the space — without it, publishing is refused. See Service account.
Its own page: AI task.
Control
They decide where the flow goes. None of them transforms data.
Condition
What it is for. Taking one of two paths based on a comparison.
How to use it. Build the comparison by choosing a value, an operator, and a value. Connect both exits: Yes and No. The operators depend on the value's type:
| Type | Operators |
|---|---|
| Text | equals · does not equal · contains · does not contain · is empty · is not empty |
| Number | equals · is greater than · is greater than or equal to · is less than · is less than or equal to |
| Yes/no | is true · is false |
| List | contains · does not contain · is empty · is not empty · has exactly · has more than · has fewer than |
| Object | has the field · does not have the field |
| Any | was provided · was not provided |
Without the No path, the run does not continue when the comparison is false.
Choose a path
What it is for. Taking one of several named paths — it replaces a stack of chained conditions.
How to use it. Choose the value to evaluate and declare the paths. They are evaluated top to bottom and the first match wins. Use the default path ("Anything else") for what does not fit — without it, an unexpected value stops the run without taking any path.
Up to 12 paths.
Combine results
What it is for. Merging what came from several paths into a single value.
How to use it. Connect two or more steps to this one — the sources come from the connections, not from a list you fill in.
| Option | Choices |
|---|---|
| How to combine | One field per step (recommended) · A list, in connection order |
| Name of each source | Left blank, the step's name applies |
| If a source brings no data | Include as empty (recommended) · Leave it out · Fail |
A path that did not run appears as empty, and does not vanish: an incomplete result must not look like a complete one.
For each item
What it is for. Repeating the same treatment for each item in a list — one email per customer, one check per server.
How to use it. Choose the list and the agent that handles each item. Inside this step, the item and the index are available for assembling data. The maximum number of items is required, with a ceiling of 50.
Each item becomes a run of the chosen agent, with its own progress, visible in the timeline.
Where it stops. A list longer than the maximum fails rather than being silently truncated — truncating would deliver a partial result that looks complete.
The list is frozen when the step starts and progress is recorded. If the platform restarts midway, it resumes where it stopped — nobody receives the same email twice.
Wait
What it is for. Pausing the flow — waiting for an external system to process, respecting a window, deferring until a date.
How to use it.
| Mode | Use |
|---|---|
| For a duration | In seconds, shorter than the agent's timeout |
| Until a date and time | A fixed moment, or one from an earlier step |
The pause is durable: the run genuinely stops, consumes no resources, and comes back on its own at the appointed time. A moment already past is not an error — the step continues immediately. Ceiling of 30 days.
Human approval
What it is for. Requiring a person's decision before continuing — publishing, paying, deleting.
How to use it. Write the title and summary the person will see (they can include run data), define who may approve and, if you want, a deadline. With no deadline, it waits indefinitely.
The pause is durable: it can wait for days without consuming resources.
Produces. Whether it was approved, who decided, and the comment.
Its own page: Approval and waiting.
Call another agent
What it is for. Reusing an agent that already exists instead of duplicating its flow inside this one.
How to use it. Choose the agent and the exact active version — never "the latest". The called agent runs in the same environment as this one and returns its result to the next step.
Where it stops. A maximum depth of 3 chained calls, and the platform refuses cycles — an agent cannot call itself, directly or indirectly.
Its own page: Calling another agent.
Output
Result
What it is for. Ending the run with the final structured output — it is what the API returns to whoever triggered the agent.
How to use it. Choose the fields it returns and where each value comes from. Every agent needs at least one Result, and it has no exit: it is the end of the path.
The error path is not a step
There is no "Handle error" box in the palette. What exists is an extra exit on the steps that can fail: "If it fails".
Connecting it to another step diverts the flow when the step fails — but the step stays marked as failed, and the run's result records that a failure was handled. A handled error does not become a clean success, because whoever reads the history needs to know something went wrong.
See When something fails.
What each step supports
| Step | Error path | Retries | Timeout |
|---|---|---|---|
| Call an API | ✅ | ✅ | ✅ |
| Reshape data | ✅ | ✅ | ✅ |
| Query corporate data | ✅ | ✅ | ✅ |
| Run an automation | ✅ | ✅ | ✅ |
| Prepare data | ✅ | — | ✅ |
| Generate with a model | ✅ | — | ✅ |
| AI task | ✅ | ✅ | ✅ |
| Condition | — | — | — |
| Choose a path | — | — | — |
| Combine results | — | — | ✅ |
| For each item | ✅ | — | ✅ |
| Wait | — | — | — |
| Human approval | — | — | — |
| Call another agent | ✅ | ✅ | ✅ |
| Result | — | — | — |
Deterministic control steps do not retry, because retrying would give the same result.
What is not in the palette
Connectors — Outlook, Teams, Slack, and inbound webhooks are not steps. They are integrations configured outside the flow; inside it, what you use is Call an API.
Steps planned and not yet available — parallel paths, conditional loops, and code execution do not exist today. If a definition coming from outside asks for one of them, publishing refuses and says which: an unknown type is never silently ignored, because that would publish an agent doing less than what was designed.
Next steps
Was this page helpful?
Report a problem on this pageDo not send passwords, keys, tokens, or customer data.