LlamaIndex Workflows and LangChain LCEL both let you compose multi-step LLM pipelines. Describe the core abstraction each one uses and call out the one structural capability LlamaIndex Workflows have that LCEL does not.
Free · 2 AI evals / day
LCEL and Workflows are both ways to compose multi-step LLM pipelines, but they use different abstractions and that difference shows up the moment you need loops.
LCEL, LangChain Expression Language, composes by piping Runnables. You write `prompt | model | parser` and the runtime walks that pipe from left to right. Branching exists via RunnableBranch and parallelism via RunnableParallel, but the overall shape is a directed acyclic graph. There is no way for a later step to send work back to an earlier step.
LlamaIndex Workflows compose by events and step handlers. You decorate methods with `@step`, and each method declares which event type it consumes and which event type or types it emits. The runtime is event-loop driven. It dispatches events to whichever step handles them, and a step can emit an event that re-triggers an earlier step.
The practical consequence: Workflows can express cycles natively. Agent loops, retry with backoff, human in the loop waits. All natural. LCEL cannot. To get cycles in the LangChain ecosystem, you graduate to LangGraph, a separate library that adds a state graph on top of LCEL.
Workflows rolls the DAG and the cycle-capable orchestrator into one abstraction.
LCEL and LlamaIndex Workflows are both composition layers but they bet on different primitives.
**LCEL** treats a pipeline as a typed function composition. A Runnable is something with `.invoke`, `.batch`, `.stream` (plus async variants), and the pipe operator chains them: `prompt | model | parser`. Each step has one typed input and one typed output. Branching is RunnableBranch; parallelism is RunnableParallel; conditional logic is RunnableLambda wrappers. The runtime walks the composition from left to right, and the composition is a DAG by construction. There is no syntax for a later step to feed an earlier one.
**LlamaIndex Workflows** treats a pipeline as event-driven handlers. You define a Workflow class with `@step`-decorated methods. Each step takes an event type as its argument and returns one or more event types as its output. The runtime dispatches events to whichever step accepts them; a step that emits an event of type `RetryEvent` re-triggers the step that consumes `RetryEvent`, even if that step ran earlier.
The structural capability Workflows has and LCEL does not is **cycles**. Agent loops naturally write as `ThinkStep` emits an `ActStep`-event, `ActStep` emits a `ThinkStep`-event, repeat until a `StopEvent` is emitted. Retry with backoff writes as a step that emits its own input-event on failure. Human in the loop waits write as a step that emits a `WaitEvent` and resumes when an external trigger emits a `ResumeEvent`.
LCEL cannot express any of these in pure form. The LangChain answer is to graduate to LangGraph, a separate library that wraps LCEL with a state graph offering exactly the cycle-capable orchestration Workflows has built in.
The practical implication is that LlamaIndex bundles the DAG composition layer and the cycle-capable orchestration into one abstraction, while LangChain ships them as two libraries.
Quick reference
TL;DR
LCEL pipes Runnables in a DAG; LlamaIndex Workflows dispatches events to step handlers and supports cycles natively, so agent loops do not need a separate library like LangGraph.
Picture two ways to build a pinball machine. The first uses ramps and gates set up in a fixed path. The ball goes in one end, rolls through the gates in order, and comes out the other end. You cannot send the ball back to an earlier ramp without adding new physical hardware. The second uses lights and sensors: the ball can trigger any sensor at any time, and each sensor can light up other sensors anywhere on the board. The ball can revisit the same ramp over and over because the wiring is logical, not physical. LCEL is the first machine; Workflows is the second.
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.
Pure linear pipelines with no loops, no conditionals, no concurrency LCEL's pipe syntax is simpler and reads more naturally; Workflows is overkill
Teams deeply invested in the LangChain ecosystem with no LlamaIndex usage Adopting Workflows means a second framework; LangGraph is the lower-friction path
Workflows that must integrate with LangSmith's polished trace UI Workflows traces flow into LlamaIndex's tooling (and OTel-based vendors); LangSmith works best with LangChain-native pipelines
Quick scan · 2–4 min
Everything important, quickly.
5 minutes: the two primitives, the DAG-versus event dispatch difference, the cycle capability, and how LangGraph fills the gap on the LCEL side.
Side-by-side
Axis
LCEL (LangChain)
Workflows (LlamaIndex)
Primitive
Runnable + pipe operator
@step methods + events
Composition shape
DAG, left to right
Event dispatch, any topology
Cycles
Not supported in pure LCEL
Native
Branching
RunnableBranch
Step emits different event types
Parallelism
RunnableParallel
Multiple steps consume same event
Cycle-capable cousin
LangGraph (separate library)
Built in
Real-world examples
Real products, models, and research that use this idea.
1LlamaIndex 0.13 ships Workflows as the recommended orchestration layer for agent-style pipelines.
2LangGraph 1.x is LangChain's separate library for cycle-capable orchestration, layered on top of LCEL.
3Replit Agent and Cursor's background tasks both use cycle-capable orchestration; the choice between Workflows and LangGraph is one of ecosystem affinity.
4DSPy's compile loop is itself cycle-capable but lives outside both LCEL and Workflows. It is a different layer entirely.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you express a supervisor-worker pattern in Workflows?
Sign in or go Pro to see the approach for this follow-up.
QCompare Workflows' event dispatch to LangGraph's conditional edges as agent-loop mechanisms.
Sign in or go Pro to see the approach for this follow-up.
QWhat does Workflows' built-in visualization show that LCEL cannot easily display?
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
Trying to express an agent loop in pure LCEL and getting stuck because the DAG cannot revisit earlier steps without graduating to LangGraph.