A network is a small set of blocks, used well
Every network — from a five-stage Monday report to a forty-stage compliance review — is built from the same small set of blocks. Once you know what each block does, you can read any network at a glance and build a new one without feeling lost.
This page is the quick tour.
Most networks use four or five blocks total. You don't need every type to build something useful. Master the LLM Agent step and the Router, and you can build 80% of the networks your team will ever need.
The five blocks
LLM Agent step
The workhorse. One specialist doing one job — drafting, analyzing, summarizing, planning.
Tool step
A direct action. Fetch a webpage. Generate a PDF. Search a knowledge base. Send an email.
Router
A branching point. "If the input looks like X, go this way. If it looks like Y, go that way."
Aggregator
The opposite of a router. Combine several parallel results into one cohesive output.
Sub-network
A whole network used as a single step inside another network. The reuse block.
The next sections go through each one with a short scenario.
LLM Agent step
The most common block. One step that hands a brief to a specialist and gets a draft, an analysis, a plan, or a summary back.
You give it:
- What to do. A clear instruction. “Summarize this transcript for the on-call engineer.”
- The inputs it should read. Files, source content, the output of an earlier step.
- Any constraints. Length, tone, audience, format.
You get back a single output that flows into the next step.
When to reach for it
Almost always, at least once. A network with no LLM Agent step is unusual — it’s where most of the AI thinking happens.
A short scenario
A research stage hands a 12-page market report to an LLM Agent step. The instruction: “Pull out the three claims about EU regulation and quote the source paragraph for each.” The output: a clean three-item list, each with a quoted source. That output flows into the next stage.
Tool step
When you need an action, not a thought, you reach for a Tool step. Tools do things — fetch a webpage, generate a document, run a search, send an email, call an API.
A Tool step doesn’t reason. It executes. The result is data, not commentary.
When to reach for it
Whenever you need a concrete, repeatable action: fetching a fresh webpage, generating a PDF, querying a knowledge index, sending a result somewhere external.
A short scenario
A network that produces a weekly customer brief uses a Tool step to fetch the latest pages from a competitor’s blog. The tool returns the page contents. The next step — an LLM Agent — summarizes them.
See Tool catalog for the full list of tools you can place in a step.
Router
A Router is a branching block. Based on the input it receives, it decides which path the workflow continues on.
The condition is usually written in plain language:
- “If the input mentions the EU, go to the EU-compliance branch.”
- “If the customer is in the enterprise segment, go to the enterprise branch.”
- “If the analysis returned a high-risk signal, go to the review branch.”
When to reach for it
Whenever the same kind of input might need a different kind of treatment. Routers are how networks stay sharp without becoming sprawling.
A short scenario
A network that triages incoming support questions uses a Router. If the question is about billing, it goes to a billing-specialist branch. If it’s about a product feature, it goes to a product branch. If it’s neither, it goes to a general-purpose branch. One network, three sharp paths.
Aggregator
The opposite of a Router. An Aggregator takes several inputs — typically the outputs of parallel branches — and combines them into one cohesive result.
The instruction tells the aggregator how to combine. “Merge these three drafts into a single document.” “Reconcile these findings and produce one set of recommendations.” “Pick the highest-confidence answer.”
When to reach for it
Whenever you’ve fanned out work across multiple parallel paths and need to bring it back together.
A short scenario
A vendor evaluation network runs three independent reviews in parallel — security review, pricing review, fit review. An Aggregator merges them into one recommendation document with a section per review and an executive summary at the top.
Sub-network
A Sub-network is a whole network used as a single step inside another network.
Why this matters: most teams accumulate small, well-tested networks for narrow jobs — “summarize a meeting transcript,” “extract obligations from a contract,” “produce a tear-sheet from a customer file.” You don’t want to rebuild those inside every new larger network. You drop them in as a single step.
When to reach for it
Whenever a job you’d put inside your current network is already a network of its own. Especially powerful for organizations where one team builds reusable building-block networks and another team composes larger workflows out of them.
A short scenario
A monthly business review network uses the “tear-sheet” sub-network as a step. The sub-network handles all the pulling, sorting, and formatting for one customer’s tear-sheet. The parent network calls it once per top customer and uses the outputs in the rest of the workflow.
How blocks combine
A few patterns you’ll see again and again.
The simple chain
LLM Agent → LLM Agent → LLM Agent. Each step refines the work of the one before it. Most “draft → critique → polish” networks look like this.
The fan-out, fan-in
One LLM Agent → three parallel LLM Agents → an Aggregator. Used when you want several independent perspectives on the same input.
The triage
Router → one of several LLM Agents → optional Aggregator. Used when the input shape varies and each shape needs different treatment.
The composition
LLM Agent → Sub-network → LLM Agent. Used when part of the work is already encoded in another network.
Reading a network at a glance
Open any network and you’ll see the blocks arranged left to right (or top to bottom, depending on your view). A short habit that helps:
- Read the block types first. What’s a step, what’s a router, what’s a sub-network. The shape of the network tells you a lot.
- Read the connections second. Where does each output flow? Are there parallel branches? Where do they reconverge?
- Read the instructions last. What does each block actually do.
In ten seconds you can answer “what kind of workflow is this?” without reading a single instruction.
A few patterns to avoid
- A network that’s all LLM Agent steps and no Tool steps. Sometimes that’s right. Often it means the network is doing thinking it could be doing lookup for instead — and the result would be sharper if it pulled data instead of trying to remember it.
- A network with five Routers in a row. Possible, but usually means the logic should live inside one block, not five.
- An Aggregator with nothing to aggregate. A single input flowing into an Aggregator is a hint the block isn’t earning its place.
Small networks beat big ones. Three sharp blocks usually outperform ten generic ones. When a network feels heavy, try to remove a block rather than add one.
Where to go next
- Triggers and schedules — what starts a network running.
- Tool catalog — every tool a Tool step can call.
- Runs and monitoring — what you see when blocks light up.
- Building workflows — go from blocks to a finished network.