Wire Your Agents Into a Workflow You Can Call Like an API.

Drag nodes onto a canvas, connect them, and ThinkStack runs the whole sequence end to end. Every step is traced, every version is published, and the finished flow answers a single POST request.

Book a Demo Watch the Live Demo
13node types on the canvas
0lines of code required
1POST call to invoke
Flow · Contract-Renewal-Risk-Review SaveDeployTest DraftDeployed
Flow inputInputOutputdocumentStringAgentContract_RiskInputagentInputTextOutputagentResponseKnowledge BaseMSA_ClausesInputretrievalQueryOutputoutputTextAgentLegal_SummaryInputagentInputTextOutputagentResponseFlow outputOutputInputdocument
Agents Call the Tools
MCP access runs through an agent
Assistant Drafts It
Describe the flow in plain English
Traced End to End
See what each node received
Callable Anywhere
Pipelines, chat, your own app
See It in Action

A Guided, Self-Playing Walkthrough

Watch a user name a flow, describe it to the assistant in one paragraph, apply the proposed nodes and connections, run a live test, read the trace, and deploy the result. One continuous take, no cuts.

AUTO-PLAYING

Runs on load · press Replay at the end · screen-record it for a shareable video

Key Features

Built for Workflows That Call Real Tools.

A flow sits between prompting an agent and writing a full integration. It keeps the sequence explicit, the data typed, and the run inspectable.

Orchestration

Tool Invocation

An Agent node invokes the MCP tools registered to it and reasons over what comes back, so every tool call is governed by an agent you configured.

Logic

Agent Collaboration

Chain Agent and LLM nodes in one flow, each handing its output to the next step, with Condition and Iterator nodes deciding where the run goes.

Code

Canvas First

Build the whole thing by connecting nodes. An Inline Code node is there for the occasional step that genuinely needs a few lines of custom logic.

Data

Parallel Branches

Two paths can run side by side from the same node and meet again at a Collector, so independent work finishes in the time the slowest branch takes.

Runtime

Step by Step Traces

Open the trace beside a test run to read exactly what every node received and returned, including the moment a failing node stopped the flow.

Lifecycle

Versioned Publishing

Publishing moves a flow from draft to deployed, so the version your endpoint answers with is always the version you tested.

Call It From Anywhere

Every published flow is an endpoint. Invoke it from your pipelines with a single request, or run any deployed flow straight from a chat session.

POST /flow/invoke  { "id": FLOW_ID, "input": input }
Standout

Describe the Flow. Let the Assistant Lay Out the Nodes.

The assistant places the nodes for you. Tell it what you want, including the input, which agent should call which tool, and what the flow returns. It reads the request, plans the graph, and proposes each node and connection for you to approve.

Name your agents and knowledge bases exactly as they appear in your project and the assistant finds them and wires them correctly. You start from a working draft on the canvas and spend your time configuring, reviewing, and testing.

1paragraph in
18changes proposed
Approvebefore anything lands
AI Assistant
Let's prepare this configuration together!

AI Assistant

How can I help you configure this flow?

Try asking:
What nodes should I add to improve my flow? Suggest a complete flow structure for my use case. How do I add an Agent node for AI processing?
18 of 18 selected
Describe the flow you want…

Works with Your Systems

A flow is most useful when something calls it. Chat gives people a way to run one in conversation, and Pipeline gives your systems a way to run one on a schedule or an event.

Chat

Run any deployed flow inside a conversation, with the result returned in the thread.

  • Trigger a flow by name without leaving the thread
  • Answer follow-up questions against the output
  • Share a working flow with a team that writes no code
Flow Orchestrator

The Workflow in the Middle

One canvas, one published version, one endpoint. Everything else calls into it.

Pipeline

Call a published flow from a scheduled or event driven pipeline with one request.

  • Run the same flow nightly, hourly, or on a webhook
  • Feed the output into the next stage of your data work
  • Keep the orchestration logic in one reviewable place

Related Modules

Orchestration
Agent Workspaces
Collaborative canvas where multi-agent orchestrations run alongside human operators.
Build
Agentic ETL Pipelines
Trigger end-to-end data transformation graphs and extract-load jobs directly from flows.
Governance
Observability & Tracing
Trace graph node execution, step latencies, retry logs, and branch decisions in real time.

Frequently Asked Questions

Common questions about Flow Orchestrator.

How is a flow different from just calling an agent directly?+
An agent answers on its own. A flow gives you a fixed sequence — shape data, hand it to an agent, branch on a condition, format the result — with a defined input, a defined output, and a trace of every step in between.
Can one flow call multiple agents and tools?+
Yes. A flow can chain any number of Agent, LLM, and Data nodes in sequence, and branch or loop between them with Logic nodes like Condition and Iterator.
How does a flow call an MCP tool?+
There's no standalone "MCP Tool" node. An Agent node invokes the MCP tools registered to it directly, then reasons over what comes back — so tool access always runs through an agent, not around one.
What happens if a node fails mid-run?+
The trace shows exactly where the run stopped and what the failing node received, so you can fix the configuration and re-run without guessing.
Do I need to write code to build a flow?+
No. Flows are built on the canvas by connecting nodes, or scaffolded from a plain-language description with the flow assistant. An Inline Code node covers the rare step that needs custom logic, and code is only otherwise needed if you invoke a published flow from your own application.
How do I get from an idea to a flow I can actually call?+
Six steps. Design the flow on the canvas, or describe it in plain language and let the assistant draft the node layout for you. Configure each node, test it with sample input in a live conversation, open the trace to see what each node received, publish it, and invoke it. Naming your agents exactly as they appear in your project lets the assistant wire them correctly.
Can we call a flow from our existing systems?+
Yes. Every published flow is callable with a single POST request to /flow/invoke with the flow ID and your input, so a flow can run inside existing pipelines rather than only from chat. Deployed flows can also be run directly from chat by selecting them. Publishing is what moves a flow from draft to deployed, so the endpoint always calls the version you tested.