Workflows vs agents

How it works, step by step

1. Start from the task, not the technology. Can you write down the steps in advance? Is the path the same for most inputs?
2. If yes, build a workflow. Your code runs fixed steps; each LLM call does one narrow job (classify, extract, draft). Common patterns:
   • Chain: step A's output feeds step B (outline → draft → polish).
   • Router: classify the input, then send it down the right path.
   • Parallel: run independent calls at once (check tone, check facts, check length) and combine.
   • Evaluator-optimizer: one call drafts, another checks against criteria, repeat until it passes.
3. If the steps genuinely can't be known in advance, consider an agent: give the model tools and a goal, and let it decide the next step in a loop until it's done (the agent loop).
4. Check the four agent criteria before choosing one: the task is complex and hard to specify step by step; it's valuable enough to justify extra cost and latency; models are actually capable at it; and mistakes can be caught and recovered (tests, review, undo).
5. Mix them. Real systems are usually a workflow with one agentic step where flexibility is needed (e.g. a fixed support pipeline where only "investigate the bug" is an agent).

Flow engineering

Flow engineering means designing the flow around the model: break the task into steps, give each step one clear job and a check, and decide in code what happens on failure. Instead of one huge prompt ("read this email, find the order, check the policy, write a reply"), you build small steps with validation between them.

1. Decompose the task into steps a model (or code) can do reliably.
2. Put code where code is better: routing, validation, lookups, arithmetic.
3. Add a check after each risky step: schema validation, a test, a rule, or a judge call.
4. Decide failure paths: retry, ask the user, or hand to a human.
5. Measure each step separately, so you know which one to improve.

# A WORKFLOW: your code decides every step; the model only fills in specific blanks.
def fake_llm(task: str, text: str) -> str:
    """Stand-in for one small, focused LLM call per step."""
    if task == "classify":
        return "refund" if "refund" in text.lower() else "other"
    if task == "extract_order":
        return next((w for w in text.split() if w.startswith("A") and w[1:].isdigit()), "none")
    return "Hi! Your refund for order {order} is being processed."
 
def support_workflow(email: str) -> list[str]:
    trace = []
    category = fake_llm("classify", email)                 # step 1: classify (LLM)
    trace.append(f"classify -> {category}")
    if category != "refund":                               # step 2: route (plain code)
        trace.append("route -> human queue")
        return trace
    order = fake_llm("extract_order", email)               # step 3: extract (LLM)
    trace.append(f"extract -> {order}")
    if order == "none":                                    # step 4: validate (plain code)
        trace.append("validate -> ask customer for order number")
        return trace
    reply = fake_llm("draft", email).format(order=order)   # step 5: draft (LLM + template)
    trace.append(f"draft -> {reply}")
    return trace
 
for email in ["I want a refund for A1234 please", "Refund please!", "Love the product"]:
    print(email, "=>", support_workflow(email))

I want a refund for A1234 please => ['classify -> refund', 'extract -> A1234', 'draft -> Hi! Your refund for order A1234 is being processed.']
Refund please! => ['classify -> refund', 'extract -> none', 'validate -> ask customer for order number']
Love the product => ['classify -> other', 'route -> human queue']