LlamaIndex Workflows (event-driven)

Once your LLM app has more than one step — retrieve, then check, then maybe re-retrieve, then answer — you need a way to wire those steps together that handles branching, loops, and concurrency without turning into spaghetti. LlamaIndex’s answer is Workflows, and as of 2026 it’s the recommended way to build everything on the framework, agents included.

Steps consume Events, and emit Events

A Workflow is an event-driven graph. You don’t draw nodes and edges by hand; instead you write Steps (async functions), and each step declares which Event type it consumes and which it emits. The framework routes events to the steps that handle them. The flow emerges from the event types — not from wiring.

Why events beat hand-wired chains

• Branching is natural — a step emits one of several event types; whichever step handles that type runs next. No giant if/else router.
• Loops are trivial — emit an event that an earlier step consumes, and you have a loop (with a step counter as the guard).
• Concurrency is built in — emit several events and multiple steps run concurrently; a collector step waits for them. Great for fan-out/fan-in.
• Observable — every event is a typed, loggable object, so tracing a run is reading the event stream.

from llama_index.core.workflow import Workflow, step, StartEvent, StopEvent, Event

class Retrieved(Event):
    nodes: list

class RAGFlow(Workflow):
    @step
    async def retrieve(self, ev: StartEvent) -> Retrieved:
        nodes = self.index.as_retriever().retrieve(ev.query)
        return Retrieved(nodes=nodes)

    @step
    async def synthesize(self, ev: Retrieved) -> StopEvent:
        answer = synthesize(ev.nodes)        # compose from the retrieved Nodes
        return StopEvent(result=answer)

# result = await RAGFlow(index=index).run(query="refund window?")

retrieve consumes the StartEvent and emits a Retrieved; synthesize consumes Retrieved and emits the StopEvent. Add a check step that emits either Retrieved (redo) or StopEvent (done) and you’ve got a self-correcting loop — no graph wiring, just event types.

Quick check

Next

Built on Workflows: LlamaIndex agents — FunctionAgent and ReActAgent that use tools over your indexes.