Describe when a fixed LCEL chain (DAG pipeline) is the better choice over an agent loop. State the single most important question to ask when choosing between them.
Free · 2 AI evals / day
A **chain** is a fixed pipeline. You wire up the steps at design time, and every run executes the same nodes in the same order. PDF in, extract text, embed, store. The graph never changes.
An agent loop is different. It hands control to the model, which decides the next action after seeing each result. The path is not fixed. The model might call one tool or ten, depending on what it finds along the way.
A chain is the better choice when you already know the steps. Because the graph is fixed, latency is predictable, cost is bounded, and debugging is easy. A failure happens at a specific node every time, so you can reproduce it.
Agents earn their extra cost only when the path genuinely depends on intermediate results. If you cannot know at design time which steps will run, because each step's output decides the next one, that is when a loop pays off.
The one question that settles it: does the execution path need to change based on what earlier steps return? If no, use a chain. If yes, use an agent.
A **chain** is preferable whenever the execution graph is known at design time. The same nodes run in the same order on every request.
That fixed structure buys three things. Latency is predictable, because there is no dynamic branching. Cost is bounded, because the LLM call count is fixed up front. Debugging is simple, because a deterministic pipeline has no emergent behaviour and failures reproduce.
An agent loop adds value only when the path genuinely depends on intermediate results. You reach for it when you cannot know in advance which steps will run, because each observation determines the next action.
The decisive question is one sentence. Does the execution path need to change based on intermediate results? If the answer is no, use a chain. If yes, use an agent.
Using an agent for a deterministic task is a net loss. You pay for extra LLM round trips, inherit unpredictable latency and cost, and take on debugging complexity, all with zero upside. The guiding rule is to prefer the simplest thing that works. Escalate to a loop only when dynamic control flow is truly required.
Quick reference
TL;DR
Prefer a fixed chain unless the execution path must change based on intermediate results; the decisive question is whether all steps are known at design time.
Think of it like two ways to cook dinner. A chain is a recipe card you follow top to bottom every time: chop, fry, plate. You always do the same steps in the same order, so you know exactly how long it takes and what it costs. An agent is a chef with no recipe who tastes the food, decides what to do next, and keeps adjusting until it is right. The chef is more flexible, but you cannot predict how long they will take or how much they will spend. If your dinner is always the same dish, the recipe card wins every time. You only need the improvising chef when you genuinely do not know the steps in advance, because what you find halfway through changes what you do next.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
The pipeline branches on a known condition, such as routing by document type at one node. A conditional edge in a chain handles fixed branching without paying for a full dynamic loop.
A prototype where you do not yet know the task structure and need to explore quickly. An exploratory agent can reveal the real steps, which you then harden into a chain for production.
The task truly needs open ended multi-step problem solving with unknown step count. A fixed chain cannot express a path that genuinely depends on what each step returns.
Quick scan · 2–4 min
Everything important, quickly.
Define the chain versus agent distinction as control flow ownership, state the decisive question about intermediate results, walk the latency, cost, and reliability tradeoffs, then close with the default to simplest rule and when to escalate from a chain to a full loop.
Side-by-side
Dimension
Fixed chain (LCEL / DAG)
Agent loop
Control flow
Engineer decides at design time
Model decides at runtime
Execution graph
Static, same every run
Dynamic, depends on observations
Latency
Bounded and predictable
Unbounded, scales with step count
Cost
Fixed LLM call count
Compounds super linearly with steps
Debugging
Reproducible, flat failure surface
Emergent, hard to reproduce
Use when
Steps known up front
Path depends on intermediate results
Real-world examples
Real products, models, and research that use this idea.
1A document ingestion pipeline (extract, chunk, embed, upsert to a vector store) is a textbook chain: the same nodes run every time, so LangChain LCEL or a plain DAG gives bounded cost and latency.
2LangGraph models both ends of the spectrum: a linear StateGraph is effectively a chain, while adding loop back edges and a model driven router turns the same graph into an agent.
3Plain RAG (retrieve once, then generate) is a two node chain; teams only escalate to agentic RAG when a query needs multi-hop retrieval that depends on what the first hop returned.
4Coding agents like Cursor and Cline must be loops because the next edit depends on test output, whereas a CI lint and format step stays a fixed chain because its graph never branches.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QYour pipeline has one branch that depends on a classification step. Chain with a conditional edge, or agent?
Sign in or go Pro to see the approach for this follow-up.
QHow would you quantify the cost and latency penalty of choosing an agent over a chain for the same task?
Sign in or go Pro to see the approach for this follow-up.
QWhen does it make sense to start with an agent and later refactor into a chain?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Reaching for an agent by default because it sounds powerful. Most production tasks have a fixed graph, so a chain is cheaper, faster, and far easier to debug.