Workflow vs Agent: Know What You Want First
Predefined flows vs model-driven decisions — Anthropic's two categories of Agent systems
THE QUESTION THIS PAGE ANSWERS
ANSWER FIRSTWhat is the key idea behind “Workflow vs Agent: Know What You Want First”?
Predefined flows vs model-driven decisions — Anthropic's two categories of Agent systems
Make the claim earn its place. Use this page as a decision aid, not a definition to memorize. Connect the idea to one real task, one observable result, and one failure that would change your mind.
Write one question you could answer with evidence after trying this idea.
A conclusion that sounds complete but leaves the key assumption untested.
Every AI product manager should commit this to memory. The industry is flooded with Agent frameworks (LangChain, AutoGen, CrewAI...), but production environments have repeatedly proven: the systems that work best use the simplest composable patterns.
| Dimension | Workflow | Agent |
|---|---|---|
| Control | Developer (fixed code path) | Model (dynamic at each step) |
| Predictability | High — same input, same execution path | Low — same input may yield different paths |
| Best fit | Well-defined tasks, fixed steps | Open-ended tasks, flexible decisions needed |
| Cost | Predictable (fixed number of calls) | Uncertain (loop count unknown) |
| Debug difficulty | Low (deterministic path, easy to reproduce) | High (non-deterministic, hard to reproduce) |
| Typical examples | Copywriting pipelines, data-cleaning pipelines | Cursor, Claude Code, Devin |
A common over-engineering mistake: using an Agent framework to solve a problem that could be handled with one Prompt plus one search. The latency, cost, and non-determinism a framework introduces far outweigh its benefits.
- 1 Try a single LLM call first: optimize your Prompt, add Few-shot examples, tune Temperature
- 2 Not enough? Add Retrieval-Augmented Generation (RAG): give the LLM access to external knowledge
- 3 Still not enough? Use a Workflow: break the task into multiple steps and control the flow with code
- 4 Genuinely need flexible decision-making? Only then reach for an Agent: let the model plan and execute autonomously
Why “Core Insight” can find relevant content
“Every AI product manager should commit this to memory.” moves retrieval beyond storing material: the real question is how to find what is relevant. That decision shapes the input quality of RAG, recommendation, and image-search systems.
Similarity is not the answer
In the flow described by “Every AI product manager should commit this to memory.”, embeddings place items in a comparable semantic space and a neighbor index narrows the search. The final answer still depends on whether the retrieved chunks cover the question, whether the distance metric fits, and whether the evidence is current.
- 1 Try a single LLM call first: optimize your Prompt, add Few-shot examples, tune Temperature
- 2 Not enough? Add Retrieval-Augmented Generation (RAG) : give the LLM access to external knowledge
- 3 Still not enough? Use a Workflow : break the task into multiple steps and control the flow with code
Separate findable from relevant
Turn “Every AI product manager should commit this to memory.” into a small test: prepare queries with known answers, record relevance, misses, and distractors, then decide whether chunking, the index, or reranking needs to change.
From “Core Insight” to “Two Core Concepts”
“Core Insight” grounds the problem in “Every AI product manager should commit this to memory. The industry is flooded with Agent frameworks (LangChain, AutoGen, CrewAI...), but production environments have repeatedly proven: the systems that work be…”. “Two Core Concepts” then moves it toward “Workflow LLMs and tools are orchestrated through predefined code paths . The developer decides the execution order at code-write time: do A, then B, then C. Keywords: determinism, predictability, developer-cont…”. Together, they show that the lesson is not just a conclusion to remember, but a claim with conditions.
Carry the judgment into the next situation
The same logic applies to retrieval: define what counts as relevant, check whether recall covers the question, and then inspect whether ranking, chunking, or freshness pushed useful evidence out.
- “Core Insight”: Every AI product manager should commit this to memory. The industry is flooded with Agent frameworks (LangChain, AutoGen, CrewAI...), but production environments have repeatedly proven: the systems that work be…
- “Two Core Concepts”: Workflow LLMs and tools are orchestrated through predefined code paths . The developer decides the execution order at code-write time: do A, then B, then C. Keywords: determinism, predictability, developer-cont…
- “The closing point”: 4 Genuinely need flexible decision-making? Only then reach for an Agent : let the model plan and execute autonomously
The final “The closing point” brings the discussion to “4 Genuinely need flexible decision-making? Only then reach for an Agent : let the model plan and execute autonomously”. The useful thing to carry forward is knowing which judgments must be revisited when input, scale, or risk changes.
I turned one judgment from this article into a small experiment I could run today. Knowing what to observe next is more useful than simply remembering the conclusion.
After reading this, I first looked for the conditions behind the idea instead of copying the method into a project. That order made the later trade-offs much clearer.
When this judgment reaches real work, which constraint should be added first? I am curious which step matters most between reading and the first practical attempt.
No discussion on this article yet.