Blocks are the building components you connect together to create AI workflows. Think of them as specialized modules that each handle a specific task—from chatting with AI models to making API calls or processing data.
Core Block Types
SteelEngine provides essential block types that handle the core functions of AI workflows:
Processing Blocks
- Agent - Chat with AI models (OpenAI, Anthropic, Google, local models)
- Chat - Run the workspace assistant with access to workspace context, memory, and tools
- Function - Run custom JavaScript or Python code
- API - Connect to external services via HTTP requests
- Webhook - Send a POST request to an external webhook URL
- PDF Creator - Use an AI document agent to write, render, and visually review a PDF. Takes Messages, an optional Style Guide, File Name, and Images. Returns the generated file as
fileId,fileName,mimeType, andfile - PPTX Creator - Use an AI presentation agent to write, render, and visually review a slide deck. Takes Messages, an optional Style Guide, File Name, Slide Layout, and Max Slides. Returns the generated file as
fileId,fileName,mimeType, andfile
Logic Blocks
- Condition - Branch workflow paths based on boolean expressions
- Router - Use AI to intelligently route requests to different paths
- Evaluator - Score and assess content quality using AI
- Judgment - Classify, decide yes or no, or score content with TypeSafe Jev, and branch on the typed answer and its probabilities
- Laya Decision - Fast typed decisions with probabilities from Laya, a decision model SteelEngine hosts itself, with no API key or per-call cost
- Guardrails - Validate content as JSON, against a regex, for PII, or against a knowledge base before it moves on
Control Flow Blocks
- Variables - Set and manage workflow-scoped variables
- Wait - Pause workflow execution for a specified time delay
- Human in the Loop - Pause for human approval and feedback before continuing
- Loop - Run the blocks inside a container repeatedly
- Parallel - Run the blocks inside a container across concurrent branches
- Parallel Window - Run a container over a collection, with at most a set number of items (1-20) active at once
- Workflow - Run another workflow as a step in this one
Data Blocks
These blocks reshape arrays and records without code. Each takes its input from an upstream block reference such as <api.data> and returns the fields named below. The transform blocks also return the primary output as result.
- API Batch - Run an array of HTTP requests with bounded concurrency, shared default headers, and per-request overrides. Takes a list of requests. Returns
resultsin input order withsuccessCount,errorCount, andtotalCount - Array Filter Sort - Filter, sort, dedupe, offset, and limit a list of records. Takes an array and filter rules. Returns
itemsandcounts - Array Group - Group records by a key path, as an array of groups or a key-to-values map, with optional aggregations. Takes an array and a key path. Returns
groups,map, andcounts - Array Join - Join two record arrays by key paths with left, inner, right, or full semantics. Takes primary and secondary arrays. Returns
rows,matched,unmatchedPrimary,unmatchedSecondary, andcounts - JSON Mapper - Reshape an object or array with path, template, and constant mappings. Takes an input value and a mapping list. Returns
resultsandcount - Record Diff - Compare current and desired record arrays by key. Takes two arrays. Returns
create,update,delete,unchanged, andcounts - Validate Records - Validate and normalize records against rules, then split, annotate, or fail. Takes an array and rules. Returns
records,valid,invalid,errors, andcounts
Output Blocks
- Response - Format and return final results from your workflow
Other Blocks
- Credential - Hold a credential that other blocks reference
- Note - Leave Markdown notes (with YouTube embeds) on the canvas for collaborators. Notes do not execute and have no outputs
How Blocks Work
Each block has three main components:
Inputs: Data coming into the block from other blocks or user input Configuration: Settings that control how the block behaves Outputs: Data the block produces for other blocks to use
Receive Input: Block receives data from connected blocks or user input
Process: Block processes the input according to its configuration
Output Results: Block produces output data for the next blocks in the workflow
Connecting Blocks
You create workflows by connecting blocks together. The output of one block becomes the input of another:
- Drag to connect: Drag from an output port to an input port
- Multiple connections: One output can connect to multiple inputs
- Branching paths: Some blocks can route to different paths based on conditions
Common Patterns
Sequential Processing
Connect blocks in a chain where each block processes the output of the previous one:
User Input → Agent → Function → ResponseConditional Branching
Use Condition or Router blocks to create different paths:
User Input → Router → Agent A (for questions)
→ Agent B (for commands)Quality Control
Use Evaluator blocks to assess and filter outputs:
Agent → Evaluator → Condition → Response (if good)
→ Agent (retry if bad)Block Configuration
Each block type has specific configuration options:
All Blocks:
- Input/output connections
- An error output handle that routes execution when the block fails
AI Blocks (Agent, Router, Evaluator):
- Model selection (OpenAI, Anthropic, Google, local)
- API keys and authentication
- Temperature and other model parameters
- System prompts and instructions
Logic Blocks (Condition, Function):
- Custom expressions or code
- Variable references
- Language selection (Function)
Integration Blocks (API, Response):
- Endpoint configuration
- Headers and authentication
- Request/response formatting
- Request timeout and retries (API)
Agent Block
Connect to AI models and create intelligent responses
Function Block
Run custom code to process and transform data
API Block
Integrate with external services and APIs
Condition Block
Create branching logic based on data evaluation
Human in the Loop Block
Pause for human approval and feedback before continuing
Variables Block
Set and manage workflow-scoped variables
Wait Block
Pause workflow execution for specified time delays