On this article, you’ll discover ways to distinguish agentic workflows from autonomous brokers by specializing in who owns management circulation \u2014 a human writing code upfront, or a mannequin reasoning at runtime.<\/p>\n
Matters we are going to cowl embody:<\/p>\n
Why the actual axis separating these techniques is predictability versus autonomy, not whether or not an LLM is concerned.
\nHow deterministic workflows, orchestrated workflows, reactive brokers, and autonomous multi-agent techniques differ, with runnable code that makes the control-flow distinction concrete.
\nWhy workflows, not totally autonomous brokers, dominate manufacturing right now, and why hybrid architectures are the sample that holds up.<\/p>\n
![\"Agentic](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2026\/06\/MLM-Shittu-Agentic-Workflow-vs.-Autonomous-Agent-scaled.png\")
<\/p>\n
Introduction<\/h2>\n
Deloitte initiatives that by 2027, as much as 50% of firms utilizing generative AI can have launched agentic AI pilots or proofs of idea. That\u2019s a wave of adoption large enough that the phrase \u201cagentic\u201d has began protecting virtually something with an LLM name in it, from a set five-step pipeline the place step three occurs to name GPT for a abstract to a totally self-directing system that plans its personal path with no script in any respect.<\/p>\n
These aren’t the identical factor. Treating them as interchangeable results in one among two errors: over-engineering a easy, well-understood process with pointless autonomy, or under-engineering a genuinely open-ended drawback by forcing it right into a inflexible pipeline that breaks the second actuality deviates from the plan.<\/p>\n
Anthropic attracts the foundational line of their broadly cited \u201cConstructing Efficient Brokers\u201d piece: workflows are techniques the place LLMs and instruments are orchestrated by way of predefined code paths. Brokers are techniques the place LLMs dynamically direct their very own course of and gear utilization, sustaining management over how they accomplish a process. Every little thing on this article is detailed beneath that one distinction.<\/p>\n
This piece maps the complete spectrum of deterministic workflows, orchestrated techniques, reactive single brokers, and autonomous multi-agent techniques, with code at every stage that makes the control-flow distinction concrete fairly than summary. The code right here illustrates structure, not a deployable system; the purpose of every snippet is to indicate who decides what occurs subsequent, to not ship a characteristic.<\/p>\n
The Actual Axis Isn\u2019t \u201cAI vs. No AI\u201d: It\u2019s Predictability vs. Autonomy<\/h2>\n
Earlier than evaluating architectures, it\u2019s price changing the mistaken query. The query isn\u2019t \u201cdoes this technique use an LLM.\u201d Virtually all the things does now. The 2 questions that really matter, borrowing a framing that\u2019s gained actual traction in structure circles, are: does this course of should be repeatable, auditable, and explainable step-by-step? And: is the proper path even recognized upfront, or does the system want to find it at runtime?<\/p>\n
A system can lean closely on an LLM and nonetheless be totally deterministic in construction \u2014 a set pipeline the place one step occurs to name a mannequin for textual content technology, however the subsequent step is hardcoded no matter what comes again. A system can be \u201cagentic\u201d with little or no actual autonomy: a tightly scripted loop with solely two allowed actions and a tough step restrict. The presence of an LLM name will not be the sign. Possession of management circulation is.<\/p>\n
Google Cloud\u2019s personal design-pattern documentation attracts this precise line operationally: deterministic workflows embody duties with a clearly outlined path recognized upfront, the place the steps don\u2019t change a lot from one run to the subsequent. Workflows that require dynamic orchestration contain issues the place the agent should decide one of the simplest ways to proceed, with no predefined script. That\u2019s the spectrum this text walks by way of, one stage at a time.<\/p>\n
Deterministic Workflows<\/h2>\n
That is the baseline. A deterministic workflow has a recognized sequence of steps determined at design time, by a human, in code. An LLM can sit inside any step \u2014 producing textual content, classifying enter, drafting a abstract \u2014 nevertheless it doesn’t select what occurs after its personal step runs. The orchestrating code does that, no matter what the mannequin returns.<\/p>\n
\n# deterministic_pipeline.py
\n# Stipulations: none past Python’s commonplace library
\n# Run: python deterministic_pipeline.py
\n
\ndef mock_llm_classify(textual content: str) -> str:
\n “””
\n Mock LLM name — stands in for an actual API name to maintain this instance
\n runnable with out an API key. The purpose is structural: no matter this
\n returns, the NEXT operate that runs is already determined under.
\n “””
\n if “refund” in textual content.decrease() or “cost” in textual content.decrease():
\n return “billing”
\n return “common”
\n
\ndef extract(raw_input: str) -> str:
\n “””Step 1 — all the time runs, all the time results in step 2. No branching right here.”””
\n return raw_input.strip()
\n
\ndef classify(cleaned_text: str) -> str:
\n “””
\n Step 2 — calls an LLM to provide a label, however the label has no impact
\n on which operate runs subsequent. That is the deterministic half: the mannequin
\n fills in a chunk of information, it would not affect the route.
\n “””
\n label = mock_llm_classify(cleaned_text)
\n print(f” [classify] LLM returned label=”{label}” (informational solely)”)
\n return cleaned_text
\n
\ndef summarize(cleaned_text: str) -> str:
\n “””Step 3 — all the time runs after step 2, whatever the label from step 2.”””
\n return f”Abstract: {cleaned_text[:40]}…”
\n
\ndef notify(abstract: str) -> str:
\n “””Step 4 — all the time runs final. The trail is mounted at design time.”””
\n return f”Notification despatched: {abstract}”
\n
\ndef run_deterministic_pipeline(raw_input: str) -> str:
\n “””
\n The management circulation right here is written solely by a human, upfront.
\n Each run takes the an identical path: extract -> classify -> summarize -> notify.
\n The LLM name inside classify() produces a label, however that label is rarely
\n used to resolve what operate runs subsequent — it is information flowing by way of a set pipe.
\n “””
\n step1 = extract(raw_input)
\n step2 = classify(step1)
\n step3 = summarize(step2)
\n step4 = notify(step3)
\n return step4
\n
\n
\nif __name__ == “__main__”:
\n # Two inputs that the LLM would classify utterly in another way
\n result_1 = run_deterministic_pipeline(“I desire a refund for my final cost”)
\n result_2 = run_deterministic_pipeline(“What are your corporation hours?”)
\n
\n print(f”nResult 1: {result_1}”)
\n print(f”End result 2: {result_2}”)<\/p>\n
1<\/p>\n
2<\/p>\n
3<\/p>\n
4<\/p>\n
5<\/p>\n
6<\/p>\n
7<\/p>\n
8<\/p>\n
9<\/p>\n
10<\/p>\n
11<\/p>\n
12<\/p>\n
13<\/p>\n
14<\/p>\n
15<\/p>\n
16<\/p>\n
17<\/p>\n
18<\/p>\n
19<\/p>\n
20<\/p>\n
21<\/p>\n
22<\/p>\n
23<\/p>\n
24<\/p>\n
25<\/p>\n
26<\/p>\n
27<\/p>\n
28<\/p>\n
29<\/p>\n
30<\/p>\n
31<\/p>\n
32<\/p>\n
33<\/p>\n
34<\/p>\n
35<\/p>\n
36<\/p>\n
37<\/p>\n
38<\/p>\n
39<\/p>\n
40<\/p>\n
41<\/p>\n
42<\/p>\n
43<\/p>\n
44<\/p>\n
45<\/p>\n
46<\/p>\n
47<\/p>\n
48<\/p>\n
49<\/p>\n
50<\/p>\n
51<\/p>\n
52<\/p>\n
53<\/p>\n
54<\/p>\n
55<\/p>\n
56<\/p>\n
57<\/p>\n<\/div>\n
# deterministic_pipeline.py<\/span><\/p>\n # Stipulations: none past Python’s commonplace library<\/span><\/p>\n # Run: python deterministic_pipeline.py<\/span><\/p>\n \u00a0<\/p>\n def <\/span>mock_llm_classify<\/span>(<\/span>textual content<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0Mock LLM name — stands in for an actual API name to maintain this instance<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0runnable with out an API key. The purpose is structural: no matter this<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0returns, the NEXT operate that runs is already determined under.<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0“<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>if<\/span> <\/span>“refund”<\/span> <\/span>in<\/span> <\/span>textual content<\/span>.<\/span>decrease<\/span>(<\/span>)<\/span> <\/span>or<\/span> <\/span>“cost”<\/span> <\/span>in<\/span> <\/span>textual content<\/span>.<\/span>decrease<\/span>(<\/span>)<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>“billing”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>“common”<\/span><\/p>\n \u00a0<\/p>\n def <\/span>extract<\/span>(<\/span>raw_input<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“Step 1 — all the time runs, all the time results in step 2. No branching right here.”<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>raw_input<\/span>.<\/span>strip<\/span>(<\/span>)<\/span><\/p>\n \u00a0<\/p>\n def <\/span>classify<\/span>(<\/span>cleaned_text<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0Step 2 — calls an LLM to provide a label, however the label has no impact<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0on which operate runs subsequent. That is the deterministic half: the mannequin<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0fills in a chunk of information, it would not affect the route.<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0“<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>label<\/span> <\/span>=<\/span> <\/span>mock_llm_classify<\/span>(<\/span>cleaned_text<\/span>)<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>print<\/span>(<\/span>f<\/span>”\u00a0\u00a0[classify] LLM returned label=”{label}” (informational solely)”<\/span>)<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>cleaned_text<\/span><\/p>\n \u00a0<\/p>\n def <\/span>summarize<\/span>(<\/span>cleaned_text<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“Step 3 — all the time runs after step 2, whatever the label from step 2.”<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>f<\/span>“Abstract: {cleaned_text[:40]}…”<\/span><\/p>\n \u00a0<\/p>\n def <\/span>notify<\/span>(<\/span>abstract<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“Step 4 — all the time runs final. The trail is mounted at design time.”<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>return<\/span> <\/span>f<\/span>“Notification despatched: {abstract}”<\/span><\/p>\n \u00a0<\/p>\n def <\/span>run_deterministic_pipeline<\/span>(<\/span>raw_input<\/span>:<\/span> <\/span>str<\/span>)<\/span> <\/span>-><\/span> <\/span>str<\/span>:<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>“”<\/span>“<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0The management circulation right here is written solely by a human, upfront.<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0Each run takes the an identical path: extract -> classify -> summarize -> notify.<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0The LLM name inside classify() produces a label, however that label is rarely<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0used to resolve what operate runs subsequent — it is information flowing by way of a set pipe.<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0“<\/span>“”<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>step1<\/span> <\/span>=<\/span> <\/span>extract<\/span>(<\/span>raw_input<\/span>)<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>step2<\/span> <\/span>=<\/span> <\/span>classify<\/span>(<\/span>step1<\/span>)<\/span><\/p>\n \u00a0\u00a0\u00a0\u00a0<\/span>step3<\/span> <\/span>