Flows

Flow step types overview

When you build a Flow in Runtype, you assemble it from individual steps. Each step handles a specific job like calling an AI model, fetching data, or branching logic. In the Flow builder, steps are organized into four categories: AI, Context, Actions, and Replies.

This guide walks through each category so you can quickly find the right step for what you’re building.

AI

These are the core steps for working with AI models.

Run Task

Send a prompt to an AI model and get a response. This is the most commonly used step in any Flow. You can configure it to return structured output like JSON so downstream steps can use the result easily. To configure model access for your Flows, see Connecting AI model providers.

Great for: text generation, summarization, classification, analysis, extracting structured data, question answering

Run Agent

A conversational AI step with message history and tool-calling Capabilities. Unlike Run Task, an Agent maintains context across multiple turns and can use Tools like web search, Slack, and Linear to complete complex work.

Great for: multi-turn conversations, agentic workflows with tools, complex reasoning that benefits from iterative steps

If your Flow needs to call external tools or carry on a conversation, use Run Agent. For one-shot prompts, Run Task is simpler and faster.

Context

Context steps gather, store, and prepare data for your Flow.

Crawl Website

Crawl a website and extract its content. Use this when you need information from multiple pages or a fuller picture of a site’s content.

Great for: scraping documentation sites, pulling structured content from web pages, feeding website data into AI steps

Requests come from datacenter IPs

The standard Crawl Website and Fetch URL methods make requests from Runtype’s datacenter IP ranges, clearly identified as automated, non-human traffic. Many sites (news outlets, social platforms, e-commerce stores, sites behind a WAF or anti-bot service) block, rate-limit, or serve a challenge page to this kind of traffic, so a request that works in your browser can still return a 403, a CAPTCHA, or empty content.

For research or scraping where this is a constraint, the Firecrawl or Massive fetch methods (and the firecrawl / massive built-in tools) and the Exa AI Search step are usually better choices: they reach the content through the provider’s own retrieval infrastructure, handle rendering and anti-bot measures, and are tuned for research. A mixed approach also works well, for example fetch first and fall back to Firecrawl, Massive, or Exa when a site blocks the direct request.

Fetch URL

Grab content from a single URL. This step supports different fetch methods, including Firecrawl for richer scraping and Massive for hard-to-retrieve pages. For an end-to-end example that uses Fetch URL in a Flow, see Quickstart: From Flow to Live Surface.

Great for: reading web pages, pulling data from public endpoints, fetching files or documents by URL

Get Record

Load a single Record from Runtype’s data store by ID, or by type/name/filter (the most recently updated match wins). Use this when your Flow needs exactly one record.

Great for: looking up a specific customer, checking a cache entry, referencing a single saved item

List Records

Load every Record matching a type, name, or filter as an array, ordered most recently updated first. Use this when the number of matches can vary.

Great for: pulling every ticket for a customer, loading a knowledge base collection, referencing multiple saved items

Upsert Record

Create a new Record or update an existing one. This is how your Flows save data back to Runtype for future use. For the underlying Record model, see Creating and managing records.

Great for: saving conversation history, caching AI results, storing processed data, building a knowledge base over time

Update Record

Modify specific fields on an existing Record without replacing it entirely. See Creating and managing records if you need the underlying Record model.

Great for: updating a Record’s status, appending new metadata, changing individual fields

Search the web using AI-powered search engines like Exa, or use model-based search to find relevant information.

Great for: finding current information, researching topics, augmenting AI responses with up-to-date web data

Generate Embedding

Convert text into vector embeddings using an AI model. This is the first step in building semantic search into your Flows.

Great for: preparing data for similarity search, building RAG pipelines

Find similar content by comparing vector embeddings. This works with your connected vector store, such as Weaviate or pgvector.

Great for: semantic search, finding related documents, powering RAG systems

Store Vector

Save vector embeddings to your vector store so they can be searched later.

Great for: building searchable embedding databases, indexing new content for RAG

Paginate API

Automatically walk through paginated API responses and collect all the results. It supports cursor, offset, page-number, and link-header pagination styles.

Great for: fetching complete datasets from APIs that return results across multiple pages

Render Template

Render a Liquid template into HTML, email-HTML, markdown, PDF, or plain text. Use this instead of a prompt step when the output is a structured document and the data is already available.

Great for: generating invoices, receipts, email bodies, reports, and other structured documents from data

Store Asset

Save a file to asset storage from a URL download or inline base64 content. Returns a public URL or a time-limited signed URL.

Great for: persisting generated files, storing downloaded content, making files available via URL

Generate PDF

Render HTML or markdown to a PDF, store it in asset storage, and return a sharable URL.

Great for: creating downloadable reports, invoices, certificates, and other PDF documents

Actions

Action steps do things. They make API calls, run code, send messages, and control how your Flow executes.

Make API Call

Send HTTP requests with full control over the method, headers, body, and authentication. This is your go-to step for integrating with any REST API.

Great for: calling third-party APIs, sending webhooks, integrating with external services

Wait Until

Pause your Flow for a set amount of time, or poll an API until a condition is met like a specific status code or response value.

Great for: waiting for external processes to finish, polling for readiness, adding delays between steps

Send Email

Send an email message with HTML content.

Great for: notifications, alerts, customer communication, sending AI-generated reports

Run Code

Execute custom JavaScript in a secure sandbox. Use this when you need to transform data, run calculations, or handle logic that does not fit neatly into other step types.

Great for: data formatting, calculations, string manipulation, parsing and restructuring JSON, custom logic

Run Code supports async/await and helper utilities. Use it when you need full programmatic control within a Flow.

Send Event

Send analytics events to PostHog. To send events to another analytics service, use an API Call step to post to its ingestion endpoint.

Great for: tracking usage, logging events, triggering analytics workflows

Set Variable

Set a Flow variable to a static value, a templated string, or a JSON object without running code. The value substitutes {{variables}}: an embedded reference is interpolated into the surrounding text, and a value that is exactly one {{reference}} keeps the original type (object, array, number, boolean, or null) instead of becoming a string. This is a lightweight alternative to Run Code when you just need to assign a value.

Great for: initializing variables, setting defaults, copying a nested field for reuse, passing values between steps

Execute Agent

Run an existing Agent with a message and capture its response. This lets you embed Agent behavior as a step within a Flow.

Great for: delegating complex reasoning to an Agent, mixing Flow control with Agent autonomy

Conditional Logic

Branch your Flow based on a condition. Define what happens when the condition is true and what happens when it is false. Each branch can contain its own sequence of steps.

Great for: if/else logic, routing based on data values, error handling, skipping steps based on conditions

Tool Call

Invoke a saved or built-in tool directly from a Flow step, without going through an AI model. Pass parameters explicitly and capture the result.

Great for: deterministic tool execution, calling APIs via saved tools, running tools as part of a data pipeline

Send Stream of Data

Stream data back to the client in real time as your Flow runs instead of waiting for the entire Flow to finish.

Great for: showing progress updates, streaming AI responses to users, real-time feedback

Working with external services

Some steps connect to external services behind the scenes:

  • AI Search can use Exa or model-based search providers
  • Fetch URL supports Firecrawl and Massive for enhanced web scraping
  • Vector Search and Store Vector work with your connected vector store, such as Weaviate, pgvector, or Cloudflare Vectorize

For actions like creating GitHub issues, sending Slack messages, or posting to Linear, use Make API Call for direct integrations, or add Tools to a Run Agent step to let the AI handle the interaction.

For fetching GitHub content, use Make API Call against the GitHub REST API (https://api.github.com), or add the GitHub tool to a Run Agent step (see GitHub integration). To clone a repository and work on it, use Run Code with a container sandbox provider.

Common Flow patterns

Most Flows follow a general shape like this:

  1. Validate and prepare — Use Run Code or Conditional Logic to check and shape incoming data
  2. Gather context — Fetch Records, call APIs, or search the web for information the AI needs
  3. Process with AI — Use Run Task or Run Agent to generate, analyze, or decide
  4. Format the output — Transform results into the shape your application expects
  5. Save and notify — Upsert Records, send emails, fire webhooks, or stream responses

You do not need every step in every Flow. A simple Flow might just be a single Run Task step. Start small and add steps as your needs grow.

Next steps