Workflows, Agents, Frameworks - Don't Let Tools Confuse You
Last Monday, Truong sent me a long message.
"Hey, I finished reading the article about 'the soul controlling AI.' I get the brain, hands, feet, ears, eyes, mouth parts. But then I Googled more and found LangChain, CrewAI, ReAct, Claude Agent SDK, AutoGen... Too many things. I don't know how to organize all this in my head for actual work."
I read it and smiled. This is a very common feeling.
The AI world is flooded with buzzwords. Every week there's a new framework. Every month there's a new pattern. Read about them and feel outdated. Don't read and fear missing out.
But actually, if you know how to organize it, everything is much simpler than you think.
The story of Minh and the pipeline
Before diving into theory, let me tell a story.
Minh had a pain point: his team maintains a large Java monorepo. Every time they write new code, they need to write unit tests, commit, create a merge request, wait for the pipeline. If it fails, read the logs, fix the bug, commit again. Loop until it passes.
Boring work. Repetitive. Minh thought: "Maybe I should use AI to automate this?"
Minh started Googling. And fell down the rabbit hole.
"What's LangChain? How is CrewAI different from LangChain? Is ReAct a framework or a pattern? Is Claude Agent SDK similar to LangChain? What about Microsoft's AutoGen?"
The more he read, the more confused he got. Minh messaged me: "Hey, I searched and found LangChain, ReAct, Agent... I don't know where to start."
I asked back a simple question: "You don't need to know what to use yet. Describe the problem first. What does AI need to do?"
Minh paused. Thought. Then described:
"Write tests. Commit. Wait for pipeline. If it fails, read logs, fix, commit again. Loop until it passes."
"That's it," I said. "You already have the design."
Minh looked confused: "But I haven't chosen any framework yet?"
"You don't need a framework. Just a loop and some APIs."
Two construction workers
Let me tell another story.
Two construction workers were given the same task: build a simple brick wall.
The first worker arrived at the site, looked at the pile of bricks and cement. He started laying bricks one by one, applying cement, building the wall. Simple. Direct. Job done.
The second worker also arrived at the site. But instead of getting to work, he spent a week researching automated construction machines. Brick-laying robots. Smart cement mixers. AI-powered progress monitoring systems. He read reviews, compared specs, joined discussion forums.
A week later, the wall still wasn't built. The second worker was still choosing machines.
Minh was being the second construction worker.
Minh's problem didn't need LangChain. Didn't need CrewAI. Didn't need any complex framework at all. Just needed to write a simple script: call an API, read the result, loop if needed.
But Minh had spent a week researching tools instead of solving the problem.
The brain already has limbs attached
Something Minh didn't know: when engineers talk about "LLM" in the context of agentic systems, they're not talking about a bare LLM.
They're talking about Augmented LLM - a brain that already has limbs attached.
Remember the article about Hands, Feet, Ears, Eyes, Mouth? Augmented LLM already has:
- Eyes to read - query databases, search knowledge bases
- Hands to act - call APIs, run code, interact with systems
- Memory to remember - store information across steps
Every "LLM" box in every architecture diagram is already a complete body. Workflows and Agents are just about how to orchestrate multiple bodies working together.
Understanding this changes everything. Workflow isn't "calling LLM multiple times." Each call can already do very complex things.
The commander and the soldier
The difference between Workflow and Agent is like the difference between two ways of commanding an army.
Workflow is like a general planning every detail before the battle.
"Team 1 attacks the left flank at 6am. Team 2 waits for the signal then strikes the right. Team 3 covers the rear after Teams 1 and 2 have advanced."
Every step is predetermined. Soldiers just need to follow the plan. No thinking required. No improvisation. If the plan is good, the battle is won.
Agent is like a special forces team dropped into the jungle.
"Mission: find and destroy the enemy base. How: up to you."
No detailed plan. The team observes the terrain themselves, decides their own path, improvises when they encounter obstacles. They have an objective, but no fixed route.
Minh's problem - write tests, commit, wait for pipeline, fix if failed - looks like an Agent because there's a loop. But look closer, it's more like a Workflow. The steps are clear. The "ground truth" is clear (pipeline passes or fails). Just loop until the goal is reached.
This is the Evaluator-Optimizer pattern - a Workflow with a loop. No complex Agent needed.
ReAct: An idea, not a product
Truong asked next: "So what's ReAct? I see people mention it all the time."
ReAct is not a framework. Not a library. Not a product you can install.
ReAct is an idea. Like "recursion" is an idea, not a programming language.
The idea is simple: when solving problems, let AI think before acting, then observe the result, then think again.
Thought → Action → Observation → Thought → ...
Just like how humans solve problems. You don't do everything in one go. You think. You try. You see the result. You adjust. You try again.
You can implement this idea any way you want. Write raw code. Use LangChain. Use Claude API. Or even write on paper and copy-paste into ChatGPT.
Pattern is the idea. Framework is the tool that implements the idea.
Don't confuse these two.
The carpenter and the IKEA cabinet
Hieu - a senior engineer on the team - told me a story.
"Back in the day, if you wanted a cabinet, you'd find a carpenter. The carpenter would measure, choose wood, cut, plane, assemble. Takes a week. But the cabinet fits your house perfectly, exactly the dimensions you need.
Now, you go to IKEA and buy one. Assemble following instructions. Few hours and done. Much more convenient. But if your house has a slightly crooked corner, the cabinet doesn't fit. You don't know how to fix it because you don't understand the structure inside.
Frameworks are like IKEA cabinets. Convenient. Fast. But when there's a problem, you don't know where to fix it because you don't understand how it works inside."
LangChain wraps everything in create_react_agent(). Very convenient. But when there's a bug, you can't see:
- What prompt is actually being sent
- What the LLM returns at each step
- Why it chose this tool instead of that one
You're standing in front of a black box. And black boxes are very hard to debug.
The path Anthropic recommends: be a carpenter first. Understand the wood. Understand the structure. Then if you need speed, buy IKEA. At least then if there's a problem, you know where to fix it.
Call the API directly first. Understand how it works. Then use a framework if you really need to.
Three questions before writing code
I told Truong: "Don't try to learn every framework. You'll never catch up. There's something new every week."
"So what should I learn?"
"Learn to ask the right questions."
Three questions. In order. Never reversed.
One: What does the problem need?
Simple (one LLM call is enough)? Workflow (clear, predefined steps)? Or Agent (open-ended, self-directing)?
Most problems are the first or second type. Agent is only truly needed when you don't know how many steps are required, and each step depends on the previous result in unpredictable ways.
Two: Which pattern fits?
If Workflow: chaining, routing, parallelization, or evaluator-optimizer?
If Agent: ReAct is the most common choice.
Three: Which tool to implement?
Direct API? Or framework?
Always start with direct API. Only use a framework when you truly need to save time and you already understand what's underneath.
Problem → Pattern → Tool. Never the other way around.
The end of Minh's story
Minh didn't use LangChain. Didn't use CrewAI. Didn't use any framework.
Minh wrote a simple Python script. Called Claude API to analyze code and generate tests. Called GitLab API to commit and monitor the pipeline. A while loop to repeat if it failed.
Less than 100 lines of code total.
Two weeks later, Minh messaged me: "Hey, the script is running great. I'm saving several hours every week."
"Which framework?" I asked jokingly.
"No framework at all. Just a loop."
That's the right answer.
Closing thoughts
The AI world will keep generating new buzzwords. Next week there might be a new framework, new pattern, new acronym.
But if you remember those three questions - Problem? Pattern? Tool? - you'll never be confused.
And always remember: start simple. Most problems don't need complex frameworks. Just a loop, a few API calls, and someone who clearly understands what problem they're solving.
Remember the article about the soul controlling AI? That soul isn't about knowing many frameworks. It's about knowing what you need.
Don't let tools confuse you. Be the one who chooses the tool, not the one chosen by the tool.
Tools will change. Patterns will evolve. But the ability to ask the right questions - that never goes out of style.