Agentic AI trackLesson 2 of 6

Workflow or Agent? The Spectrum of Autonomy

Agent or workflow is not a yes-or-no question. It is a scale, and where you stand on it is a design decision.

By Parastoo MosayebiPublished 18 October 20268 min readBased on the Agentic AI course

The short answer

Every agentic system sits somewhere on a scale from fixed steps to full freedom. The more the LLM decides, the more flexible the system gets, and the less predictable, slower and more expensive it becomes. Good design means choosing the lowest level of autonomy that still solves the problem.

Why a scale and not two boxes

In lesson 1 I used two words: workflow and agent. When I read about them, it sounds like you have to build one or the other. Andrew Ng says in his course that this is the wrong question. He asks: how autonomous is this system?

That made sense to me quickly, because real systems mix both. A fixed pipeline can have one step where the LLM chooses between two paths. An agent can be boxed in by a short list of tools and a hard step limit. The label does not tell you much. How much freedom you gave the model does.

How I think about it as a web developer

I build websites, so I know fixed flows well. A checkout has steps in a set order: cart, address, payment, confirmation. I always know what comes next, and when something breaks I know where to look. That is the left end of the scale.

A support chat is different. You do not know what the visitor will ask, so you cannot draw the whole path in advance. Something has to decide what to do next. That is where more autonomy starts to make sense, and also where I would start to feel nervous.

So my rule of thumb for now is simple. If I can draw the path like a checkout, I draw it. I only hand the decision to the model where I really cannot.

The scale, in three stops

Less autonomousSemi-autonomousHighly autonomous

The autonomy scale. The marker shows where my Job-Match Agent sits today.

Less autonomous
You fix the steps and the tools in code. The LLM only produces text inside each step.
My Job-Match Agent: extract skills, write queries, search, fetch, score, filter. The order never changes.
Semi-autonomous
You fix the list of tools. The LLM decides which one to call, and when.
A research helper that can search, fetch a page or run a calculation, and picks the next action itself.
Highly autonomous
The LLM plans the steps, picks tools, and may even write new ones.
A coding agent that reads a repository, plans a change, edits files, runs tests and tries again.

Five workflow shapes before you reach for an agent

Anthropic describes five ways to build a workflow, all on the left side of the scale. I find them useful because each one answers a different problem.

Prompt chaining: One step feeds the next, with a check in between. Good when a task splits cleanly into a fixed sequence.
Routing: A first step sorts the input and sends it to the right specialist step. Good when inputs fall into clear categories.
Parallelization: Several LLM calls run at the same time, either on parts of a task or as a vote. Good for speed or for more confidence.
Orchestrator and workers: One LLM splits a task on the fly and hands the parts to others. Good when you cannot know the subtasks in advance.
Evaluator and optimizer: One LLM writes, another gives feedback, and this repeats. Good when there are clear quality criteria.

My job matcher is a prompt chain. If I later want to treat job ads from different sources differently, a routing step would be the next small move, long before it needs to become a free agent.

What more autonomy costs

Autonomy is not free. Anthropic lists the price plainly:

Cost and speed: the model makes many more calls before it finishes. Anthropic measured about 4 times the tokens for an agent and about 15 times for a multi-agent system, compared with a chat.
Predictability: you cannot say in advance which steps it will take.
Compounding errors: a small mistake early on carries into every later step.
Testing: you need to try agents in a safe sandbox and add guardrails.

In return, you get something no fixed pipeline offers: the system can handle tasks where you cannot write down the steps in advance. Anthropic's advice is to start simple and add complexity only when results show you need it.

A newer example: Anthropic's research system

The 2024 guide is a good base, but I wanted to see a real system. In June 2025 Anthropic described how it built its multi-agent research feature. A lead agent plans the research and starts several subagents that search in parallel. Each subagent has its own context and reports back, and the lead agent puts the results together.

Two numbers stood out to me. Agents use about 4 times the tokens of a normal chat, and multi-agent systems about 15 times. In return, Anthropic reports that the multi-agent version beat a single agent by 90.2% on its own internal research test.

What I find most useful is where Anthropic says this does not fit: tasks where the agents need a lot of shared context or depend on each other, and it names most coding tasks as an example. More agents is not automatically better. It pays off for broad tasks with a lot of parallel work, and when the result is worth the cost.

How I would choose

Four questions I will ask before I build anything:

Can I write the steps down? If yes, make it a workflow.
Is the number of steps unknown, or does the next step depend on what the last one found? Then a more autonomous design may be worth it.
What happens if it gets one step wrong? If the answer is "something expensive or hard to undo", add a human check or keep it fixed.
Can I measure whether it works? Without that, more autonomy only hides problems.

For the Job-Match Agent the first answer is yes. I can write all six steps, so it stays on the left of the scale. That is a decision, not a limit.

What comes next

Lesson 3 covers the four design patterns Ng names: reflection, tool use, planning and multi-agent collaboration. Those are the building blocks you move along this scale with.

Test yourself

Take a moment to guess each answer in your head, then open the correct answer and compare.

Question 1 of 6

Why does Andrew Ng prefer a scale of autonomy to a strict split between workflow and agent?

Show the correct answer

Correct answer. Because real systems mix both. The useful question is how much the LLM decides, not which label fits. A fixed pipeline can contain one decision step, and an agent can be limited by a short tool list.

Question 2 of 6

What are the three stops on the autonomy scale?

Show the correct answer

Correct answer. Less autonomous (the developer fixes steps and tools), semi-autonomous (tools are fixed, the LLM chooses which to call) and highly autonomous (the LLM plans the steps, chooses tools and may write new ones).

Question 3 of 6

Name three of Anthropic's five workflow patterns.

Show the correct answer

Correct answer. Any three of: prompt chaining, routing, parallelization, orchestrator and workers, evaluator and optimizer.

Question 4 of 6

What does more autonomy cost you?

Show the correct answer

Correct answer. Higher cost and slower runs, less predictability, errors that compound across steps, and a greater need for sandbox testing and guardrails.

Question 5 of 6

Where does the Job-Match Agent sit on the scale, and why?

Show the correct answer

Correct answer. At the less autonomous end. The six steps and their order are fixed in code, and the LLM only reads and writes text inside them. It is a prompt chain.

Question 6 of 6

According to Anthropic's research system, when is a multi-agent setup a poor fit?

Show the correct answer

Correct answer. When the agents need a lot of shared context or depend on each other's work, for example in most coding tasks. It fits broad, parallel tasks where the result is valuable enough to pay for about 15 times the tokens of a chat.