Steroid Flows — Overview

Impact

The table below shows what changes when you replace ad-hoc prompt engineering with a structured Flow.

How It Works

Steroid Flows separates three concerns that are normally tangled together in a single chat thread:

Flow engine — the Activepieces-compatible runtime that executes steps in order, handles branching, retries, and exposes every flow as a REST endpoint via a Webhook trigger. Failures from integrations, credentials, quotas and network calls still need handling.

MCP blocks — each block is a single, authenticated call to an MCP server tool (GitHub, Linear, Postgres, Slack, …). Blocks are deterministic: given the same inputs they always call the same tool with the same parameters.

LLM nodes — reasoning steps that transform, classify, or generate text. They consume outputs from previous blocks and produce structured JSON that downstream blocks can reference after inspecting the action's wrapper. External API state/results can vary too; explicit sequencing is not a guarantee of identical outputs.

Blocks vs LLM Nodes

The REST API Pattern

Every flow that starts with a Webhook trigger is instantly a REST endpoint. The caller sends a POST, the base Live URL starts asynchronous work. Append /sync for the Return Response body or /sync-stream for SSE lifecycle events and the final response envelope.

POST /api/v1/webhooks/{flow-id}/sync
Content-Type: application/json

{ "repo": "acme/backend", "since": "2025-01-01" }

          ↓  Webhook Trigger block receives the body
          ↓  LLM Node: summarise commits
          ↓  GitHub block: create issue
          ↓  Return Response block

HTTP 200
{ "issue_url": "https://github.com/acme/backend/issues/42" }

Flows as an LLM API

You can use Flows as an LLM API by creating a flow with a Webhook Catch trigger which accepts prompt via the request body keep an LLM node after it which takes prompt as input and finally a Return Response node which returns the output. it exactly like any other MCP tool.

curl -X POST "<LiveUrl in the Webhook Trigger node>/sync" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Summarise the latest changes in the repo"
  }'

Flows as an MCP Server API

You can use Flows as an MCP Server API by creating a flow with a Webhook Catch trigger which accepts the tool call parameters in its body, then keep the tool node and pass the tool call parameters to it and finally a Return Response node which returns the output.

curl -X POST "<LiveUrl in the Webhook Trigger node>/sync" \
  -H "Content-Type: application/json" \
  -d '{
    "owner": "acme-corp",
    "repo": "backend",
    "title": "Fix memory leak in worker pool",
    "body": "Observed 200 MB/hr growth under load. See attached profile.",
    "labels": ["bug", "performance"]
  }'

# Response
HTTP 200
{ "issue_url": "https://github.com/acme-corp/backend/issues/42" }

Quick Start

1. Open the Steroid web UI and navigate to Flows in the left sidebar.
2. Click New Flow and select Webhook as the trigger.
3. Add Invoke LLM or Invoke Structured LLM — select an advertised IDE/model; the structured action also needs jsonSchema.
4. Add a generated MCP piece, for example GitHub issue_write; provide its exact required inputs and credential properties/connection references.
5. Use actual internal step names and inspected outputs, for example {{step_1.output}} for the Invoke LLM FCC response body. A whole-step reference preserves its complete wrapper.
6. Add a Return Response block and reference any output you want to return to the caller.
7. Test with safe real inputs, then publish with a description and manually entered valid-JSON trigger schema. Publication and search indexing are separate outcomes.