A complete, neutral reference for Amazon Bedrock Flows in 2026: what Flows are (a visual, drag-and-drop builder for multi-step generative-AI workflows), every node type you can drop on the canvas (prompt, knowledge base, agent, Lambda, condition, iterator, S3, Lex), how a multi-step workflow is wired visually, when a visual Flow beats writing orchestration in code (LangChain / Step Functions), versions and aliases, testing and tracing, the real use cases and limitations, what it costs — and how AWS credits make the build $0.
Amazon Bedrock Flows is the visual orchestration layer of Bedrock: a drag-and-drop canvas where you assemble a multi-step generative-AI workflow out of pre-built nodes instead of writing the glue code yourself. The clearest framing is "a visual workflow builder for GenAI."
Almost no real generative-AI feature is a single model call. A useful one is a sequence of steps: take some input, maybe look something up in your documents, run a prompt, branch based on the result, call a tool or a function, maybe loop over a list, and assemble an output. Traditionally you write that orchestration in code — chaining calls with a framework like LangChain, or wiring AWS services together with Step Functions. Bedrock Flows lets you express the same multi-step logic visually: each step is a node on a canvas, and you connect node outputs to the next node's inputs by drawing links.
The reason this is more than a convenience is that the nodes are GenAI-native and already wired into Bedrock. A prompt node is a configured model call. A knowledge-base node is a managed RAG retrieval. An agent node invokes a Bedrock Agent that can use tools. You are not gluing raw API calls together; you are composing higher-level building blocks that already know how to talk to Bedrock, with the data passing between them automatically. That is what makes a workflow that would be a few hundred lines of orchestration code into a diagram you can build and read in an afternoon.
A Flow has a defined input (what you pass in when you invoke it) and one or more outputs (what it returns). Between them, data flows along the connections you draw — the output of one node becomes the input (or part of the prompt) of the next, and the visual graph is the program. You invoke a finished Flow through the Bedrock API (the InvokeFlow operation) just like any other Bedrock capability, so it slots into an application the same way a single model call would.
Flows sits alongside the rest of the Bedrock orchestration toolkit. Agents handle the case where a single autonomous component reasons and calls tools dynamically; Knowledge Bases handle managed RAG; Prompt Management stores and versions reusable prompts. Flows is the layer that composes these into an explicit, multi-step pipeline with control flow you define — and, importantly, it can use all of them as nodes. The next sections cover the node palette, how you wire a workflow, and when a visual Flow is the right tool versus code.
Amazon Bedrock Flows is a visual, drag-and-drop builder for multi-step generative-AI workflows. You drop nodes — prompts, knowledge-base lookups, agents, your own Lambda code, conditions, loops — on a canvas and connect them; the diagram is the program, and you invoke it through the Bedrock API. It is orchestration without the orchestration code.
A Flow is built from a fixed palette of node types. Knowing what each one does is most of knowing what Flows can build — the workflow is just these blocks wired together. Here is the practical rundown of the core nodes.
Every Flow begins with an input node (the data you pass in when you invoke it) and ends with one or more output nodes (what it returns). In between, you compose from the GenAI, logic, and integration nodes below. Data flows along the connections you draw, so each node's configuration references the outputs of the nodes feeding into it.
Two things to keep in mind about the palette. First, it is fixed but composable — you cannot invent a new node type, but the Lambda node is the universal escape hatch for anything the built-in nodes do not cover, and the combination of prompt + knowledge base + agent + condition + iterator covers a very large share of real GenAI workflows. Second, the available nodes expand over time as AWS adds capabilities, so confirm the current node list in the AWS Bedrock documentation when you design a Flow. The art of building a good Flow is mostly choosing which work belongs in a prompt, which in an agent, which in a Lambda, and where conditions and loops give you the control flow you need.
The point of Flows is that a multi-step workflow becomes a diagram you assemble and read, not a code project you maintain. Here is what building one actually looks like, and a concrete example to make the data flow tangible.
In the Bedrock console you open the Flow builder — a canvas with the node palette on the side. You drag nodes onto the canvas, click each one to configure it (choose a model and write the prompt for a prompt node; pick the Knowledge Base for a knowledge-base node; select the Lambda for a Lambda node; write the expression for a condition), and then draw connections from one node's output to the next node's input. Those connections are the data flow: when the Flow runs, each node receives the outputs of the nodes connected into it, does its work, and passes its result onward. The visual graph fully defines the logic — there is no hidden code behind it.
Suppose you want a Flow that takes a topic and produces a fact-grounded, polished article. You might wire: an input node (the topic) → a knowledge base node (retrieve relevant internal research on the topic) → a prompt node (draft the article using the retrieved context) → a condition node (is the draft long enough / does it meet a quality check?) → if no, loop back or route to a stronger model; if yes → a second prompt node (edit and tighten the draft) → an S3 node (save the finished article) → an output node (return it). That entire pipeline — retrieve, draft, check, refine, persist — is a handful of connected boxes, with each prompt node's template pulling variables from the nodes upstream of it.
A second common pattern: route requests to different models by difficulty or type to control cost. A prompt node (or a small classifier) tags the incoming request, a condition node branches on the tag, and each branch is a prompt node bound to a different model — a cheap, fast model for the easy branch and a frontier model for the hard branch — converging back to a single output. The same idea, drawn rather than coded, gives you a visible, auditable router that a non-engineer can read and reason about.
For batch-shaped work: an input node receives a list of documents (or an S3 node reads them), an iterator node runs the same sub-pipeline on each one — perhaps a knowledge-base lookup plus a prompt to extract structured fields — and a collector gathers the per-document results into a single array that the output returns. The loop and the per-item logic are both visible on the canvas.
Building a Flow is choosing the right node for each step and drawing the data connections between them. Prompts generate, knowledge-base nodes ground in your data, agents handle open-ended tool use, Lambdas run your code, conditions branch, iterators loop. The diagram is the program — readable by engineers and non-engineers alike.
The honest question for any team is: should this be a visual Flow, or should I write the orchestration in code? Both are legitimate. The answer turns on flexibility, who maintains it, and how GenAI-specific the workflow is.
The two main "code" alternatives are application frameworks like LangChain (and LlamaIndex) — Python/JS libraries for chaining LLM calls, tools, and retrieval in your own codebase — and AWS Step Functions — a general-purpose visual/JSON workflow service for orchestrating any AWS work (not GenAI-specific). Bedrock Flows sits between them: visual like Step Functions, but with GenAI-native nodes (prompt, knowledge base, agent) like LangChain, and managed entirely within Bedrock.
Where Flows wins: speed to build a GenAI-shaped pipeline (the building blocks are pre-wired), readability (a diagram a product manager can follow), and zero infrastructure (no code project to deploy or operate). Where code wins: arbitrary flexibility (any library, any control flow, complex data transforms), testability with your normal engineering tooling (unit tests, version control diffs, CI), and workflows that are mostly non-GenAI heavy backend logic. Where Step Functions wins: orchestrating broad AWS workloads — long-running jobs, human-approval steps, fan-out across many services — where GenAI is only one part of a larger system.
A practical rule of thumb: if the workflow is primarily a chain of GenAI steps (retrieve, prompt, branch, agent) and you value speed and readability, build it as a Flow, dropping to a Lambda node for the occasional custom piece. If the workflow needs deep custom logic, heavy testing discipline, or a library Flows does not expose, write it with a framework in code. If it is a large operational pipeline where GenAI is one stage among many, reach for Step Functions (and you can still call a Flow, an Agent, or a model from within it). These are not mutually exclusive — many real systems use a Flow for the GenAI core and Step Functions or code around it.
A workflow you can build is only useful if you can ship it safely and debug it. Flows handles both through a versions-and-aliases model borrowed from how Lambda and Bedrock Agents are deployed, plus an in-console test-and-trace experience.
While you build, you edit a working draft of the Flow. When it is ready, you publish a numbered, immutable version — a frozen snapshot you can rely on not changing. You then point an alias (a stable, named pointer like prod or staging) at a specific version, and your application invokes the Flow by alias. The benefit is the standard one: your app calls prod, and you promote a new release by repointing the alias from version 3 to version 4 — and roll back instantly by pointing it back. You can keep editing the draft and publishing new versions without touching what production is running. This separation of "what I'm editing" from "what's live" is essential for changing a workflow safely.
The Flow builder includes a test panel: you provide sample input and run the Flow right in the console, watching it execute end to end. Crucially, you can enable trace, which surfaces the step-by-step execution — what each node received as input, what it produced as output, which branch a condition took, and where time (and tokens) went. Tracing is how you debug a Flow that returns the wrong thing: you can see exactly which node's prompt produced a bad result or which condition routed the wrong way, rather than guessing. For production observability, Flow invocations integrate with AWS's standard logging/monitoring so you can track behavior beyond the console.
| Artifact | What it is | Mutable? | What you do with it |
|---|---|---|---|
| Working draft | The Flow you are editing | Yes | Build and test changes |
| Version | Published immutable snapshot | No | Freeze a tested release |
| Alias | Named pointer to a version (e.g. prod) | Yes (repoint) | What your app invokes; promote / roll back |
Flows is excellent for a specific shape of problem and a poor fit for others. Being honest about both is the difference between a Flow that ships and one you rebuild in code three weeks later.
Flows shines wherever a workflow is a clear, multi-step GenAI pipeline. Content generation pipelines — retrieve context, draft, check, refine, publish — map directly onto a Flow. Multi-model routing — classify a request and route it to the cheapest model that can handle it — is a clean condition-plus-branches Flow and a real cost lever. Document processing — iterate over files, extract or summarize each with a prompt grounded by a knowledge base, collect the results — uses the iterator pattern well. Chatbot back-ends — a Lex front-end driving a Flow that retrieves, reasons, and responds — keep the conversation logic visible. And prototyping any GenAI workflow is faster in Flows than in code, even if you later rewrite it.
The trade-offs are the flip side of "visual." The node set is fixed — anything outside it has to go through a Lambda node, and a Flow that is mostly Lambda nodes is a sign the work really belongs in code. Flows is built for orchestration, not heavy computation — it is not where you do large data transforms or long-running batch jobs (push those to the services built for them, or Step Functions). Complex branching and deeply nested logic can get visually unwieldy on a canvas where code would be tidier. Very high-throughput or latency-critical paths may be better served by hand-tuned code. And as a relatively young capability, the exact node set, quotas, and limits evolve — confirm current constraints in the AWS Bedrock documentation before committing a production-critical workflow to a Flow.
Build it as a Flow when the workflow is a readable, multi-step GenAI pipeline and you value speed and clarity. Reach for code or Step Functions when you need arbitrary logic, heavy computation, deep testing discipline, or you find yourself routing most of the work through Lambda nodes anyway.
Flows itself is not the expensive part — the work it orchestrates is. Understanding that distinction tells you where a Flow's bill actually comes from and why AWS credits cover the whole thing during a build.
There is generally no separate premium for the visual builder; the cost of running a Flow is the cost of the work each node performs. A prompt node incurs the normal Bedrock per-token model cost (input + output) for whatever model it calls. A knowledge base node incurs the retrieval/RAG cost (the vector store plus any generation). An agent node incurs the cost of the agent's model calls and tool use. A Lambda node incurs standard Lambda invocation/compute cost, plus whatever the called code itself triggers. S3 nodes incur S3 request/storage cost. In other words, a Flow's bill is the sum of the underlying services it touches on each run — so the cost levers are the same as everywhere in Bedrock: right-size the model in each prompt node, cache stable prompts, and avoid unnecessary high-cost branches.
Because the model and supporting-service costs are the real spend, and those are exactly what AWS funds, a Flow-based feature is fully credit-eligible. Bedrock inference (the prompt and agent nodes), Knowledge Bases (the RAG nodes), Lambda, and S3 all draw down your AWS credits automatically. The relevant pools are AWS Activate (commonly up to $100K for institutionally-funded startups), a dedicated Bedrock / generative-AI POC pool ($10K–$50K) aimed at proving out exactly this kind of GenAI workflow, and the competitive Generative AI Accelerator (up to $1M). Most of these are partner-filed through the AWS Partner Network rather than a public form — which is the gap CloudRoute fills: we match you to the right pool for your stage and to a vetted AWS DevOps/ML partner who files the credit application and builds the orchestration (designing the node graph, wiring the knowledge-base and agent nodes, writing the Lambda escape-hatch code, and setting up versions/aliases for safe release). The customer pays $0 — AWS funds the credits, AWS pays the partner through engagement-funding programs, and the partner pays CloudRoute a routing commission. See AWS credits for generative-AI startups and Bedrock POC funding for the full mechanics.
A Flow costs the sum of the work its nodes do — Bedrock tokens (prompt/agent nodes) + RAG (knowledge-base nodes) + Lambda + S3 — not a separate builder fee. All of it is AWS-credit-eligible, so the build can be $0 while you prove the workflow out.
These three are the orchestration options teams most often weigh on AWS, and they solve overlapping but distinct problems. Here is how they compare on the dimensions that drive the choice. (Flows can use an Agent as a node; Step Functions can invoke a Flow — so this is about the primary tool for the job, not mutual exclusivity.)
| Dimension | Bedrock Flows | Bedrock Agents | AWS Step Functions |
|---|---|---|---|
| What it is | Visual GenAI workflow builder | Autonomous tool-using GenAI component | General-purpose workflow orchestrator |
| Interface | Drag-and-drop canvas | Configured agent (instructions + tools) | Visual + JSON state machine |
| Control flow | You define it (explicit nodes/links) | The model decides dynamically | You define it (states + transitions) |
| GenAI-native? | Yes — prompt/KB/agent nodes built in | Yes — it is a GenAI primitive | No — orchestrates any AWS work |
| Best for | Multi-step GenAI pipelines, drawn | Open-ended tasks needing dynamic tool use | Broad AWS pipelines; GenAI as one stage |
| Who can build it | Engineers + non-engineers (visual) | Engineers (config + tool APIs) | Engineers / cloud teams |
| Custom code | Via Lambda node (escape hatch) | Via action groups (Lambda/APIs) | Via Lambda/service integrations |
Situation: The product needed a multi-step pipeline: pull relevant brand and research context, draft long-form content, run a quality/length check, route weak drafts to a stronger (more expensive) model and good ones to a cheaper editor pass, then store the result. They had prototyped it in LangChain, but the chain had become hard to reason about, every change meant a code deploy, and their two ML engineers were spending more time maintaining orchestration glue than improving the product. They also did not want to burn runway on frontier-model inference while still tuning the pipeline.
What CloudRoute did: CloudRoute matched them in under 24 hours to a North-American AWS partner with GenAI orchestration experience. The partner rebuilt the pipeline as a Bedrock Flow: a knowledge-base node for brand/research context, a prompt node to draft, a condition node to branch on a quality check, two model-specific prompt nodes (a cheap editor model for good drafts, a frontier model for weak ones), and an S3 node to persist output — with a Lambda node as the escape hatch for a custom scoring step. They set up versions and aliases so the product invoked a stable "prod" alias, and used trace to debug the branching. In parallel, the partner filed a Bedrock POC credit application plus an Activate Portfolio application.
Outcome: The orchestration became a diagram the whole team — including non-engineers — could read and change, releases were a one-click alias repoint instead of a code deploy, and the multi-model routing cut average per-article cost by pushing the easy majority to the cheaper model. The entire run cost (model tokens, the knowledge-base retrieval, Lambda, S3) was covered by the approved credits, so the team paid $0 during the build and tuning. CloudRoute's commission was paid by the partner from AWS engagement funding, not by the customer.
orchestration: LangChain → Bedrock Flow · releases: code deploy → alias repoint · cost routing: easy majority → cheaper model · out-of-pocket during build: $0
Whatever your Flow runs — model calls, RAG retrieval, agents, Lambda — AWS credits can cover it. CloudRoute routes you to the right credit pool (Activate up to $100K, Bedrock POC $10K–$50K, GenAI Accelerator up to $1M) and a vetted AWS partner to design the node graph, wire the knowledge-base and agent nodes, write the Lambda code, and set up versions and aliases for safe release. Customer pays $0.