Progressive Agency

The word stopped working

A chatbot with a plugin is an agent. A scripted workflow with a language model in the middle is an agent. The macro that was called robotic process automation eighteen months ago is an agent.

The word now covers everything. A word that covers everything tells you nothing.

There is no standards body for this. No certification. No definition anyone has to honor.

Marketing filled the gap, and the industry already has a name for what happened: agent washing.

The old definition still works. In Russell and Norvig, an agent is anything that perceives its environment through sensors and acts on that environment through actuators.

A thermostat qualifies. A robot vacuum that maps a room qualifies more.

That definition is decades old, still correct, and so broad that it settles none of the arguments you are actually having with a vendor.

Here is the working definition. A system is agentic when it:

1. Is handed a goal instead of a prompt
2. Decides its own next steps
3. Acts on the world through tools
4. Observes what came back
5. Corrects and goes again

Count them. Five conditions.

Five conditions describe a range. The label hides where on that range a system actually sits, and where it sits is the only thing you needed to know before you signed.

What I wrote in 2024

In November of 2024 I published an article on LinkedIn called AI assistants versus AI agents. There were five key distinctions I made about those two. They were:

1. Autonomy
2. Proactivity vs Reactivity
3. Tool Utilization
4. Decision Making and Learning
5. Task complexity

Ultimately, assistants respond to direction and agents assess situations and act.

With assistants automation emerges when processes are already efficient and stable. But, most processes are neither efficient or stable!

If you want to prototype a workflow, use an assistant.

If you want to automate a workflow, hand a stable and valuable workflow to an agent to manage. If you do that then your agent will operate a process that is good and running instead of trying to make a bad process run faster.

Don't scale broken processes.

The part that changed

That 2024 piece treated assistants and agents as two categories with a bridge between them.

Twenty months of building later, they look like two settings on the same machine.

Here is the demonstration. It takes ten minutes and you can run it in a tool you already pay for.

Open a chat window with a good model. Ask it a question. It answers. Then it waits for you.

That is an assistant. You drive every turn.

Now use the same window, the same model, and the same session, and hand it this instead:

Goal: [the outcome]. Use the tools available. Loop through plan, act, observe, revise until [the bar is met]. Do not stop and ask me for the next step unless you are actually blocked.

Watch what happens. It breaks the goal into pieces. It picks actions. It calls tools. It reads what came back. It adjusts.

It keeps going without you.

Nothing about the model changed. The weights are identical. What changed is that you gave it an outcome instead of a task, permission to continue, and a condition for stopping.

That is the whole thing.

The vendor sells you capability. You supply the agency. Most product pages sell the first and imply the second.

The five dials

If you supply the agency, then agency has parts. Five of them. Each one turns on its own.

1. Objective. Task to outcome.

"Draft this email" is a task. "Get this account to a scheduled call, and here is what a good one looks like" is an outcome.

Only an outcome can be pursued. A task gets finished or it does not, which leaves the system nothing to iterate toward.

2. Tools. None, then read-only, then write.

Read-only is the setting almost nobody uses. Let it search, query, and inspect anything it wants, and let it change nothing.

That is most of the value at almost none of the risk.

3. Loop. One turn, then a set number of turns, then running until it clears a bar.

This is the dial that turns an assistant into something agentic.

It is also worthless without a judge. A loop that cannot honestly score itself does not converge. It drifts, and then it declares victory.

So write the success criteria before you start, and make at least one of them impossible to argue with. The test passes. The file compiles. The number reconciles. Every item on the checklist is there.

4. Memory. This conversation, then a project context, then state the system keeps between runs.

Memory is what makes the eleventh pass smarter than the first.

5. Bounds. Who approves what.

The cleanest version is LEAD:

• Lead. AI does the work. A human reviews exceptions.
• Execute. AI does the work. A human reviews everything.
• Assist. A human does the work. AI helps.
• Defer. A human does the work. AI stays out.

Every task in your business already sits at one of those four. Nobody said so out loud, but it is already true.

Sort them with two questions. What are the stakes? Can it be undone?

Reversible and low stakes moves to Lead early. Irreversible keeps a human on the exit forever, no matter how good the system gets.

Sending. Publishing. Deleting. Spending. Those stay behind a person.

The ladder

Turn the dials together and you get five levels.

Two things about this ladder matter more than the ladder itself.

First, most systems that actually work sit at L2 and L3.

That is where the economics sit right now. Reliability, memory, cost, and compounding error all get harder above L3, and the vendor quoting you an L4 price is usually shipping an L3 with a longer sales cycle.

Second, L2 is nearly free.

It is a prompt. If you already pay for a model, you can move from L1 to L2 this afternoon, in the tool you already have open, and buy nothing.

A lot of companies are convinced they need an agent platform. Most of them have never turned this one dial.

Why you climb one rung at a time

Two reasons. The first one is arithmetic.

Every rung you climb multiplies the number of steps the system takes while nobody is watching. Errors compound across those steps.

Ninety-five percent per step sounds great.

Run it across twenty unwatched steps and you get a correct result about a third of the time.

That is the real ceiling on autonomy. Going from 95 percent to 99 percent per step moves you from 36 percent to 82 percent across twenty steps, which is why per-step reliability buys more than anything else you can spend on.

Now the caveat, because that table is the pessimistic case. It assumes errors are independent and nothing catches them.

This is exactly why the verify step matters. A loop that checks its own work against a hard criterion bends that curve, and bending that curve is the entire job of the judge.

Build the loop without one and read the table straight.

The second reason is simpler.

You cannot delegate a workflow you have not defined.

The assistant phase is where the definition gets written. Every time you correct the model turn by turn, you are writing down a decision rule that used to live only in your head.

Do that for two weeks on a workflow that actually runs and you will end up holding the spec.

Skip it and you will spend a quarter debugging an autonomous system against a standard nobody ever wrote down.

So turn one dial at a time. Hold the rest still.

When it breaks, and it will, you will know which dial did it. Turn three at once and you will not know which one to undo.

The same ladder runs your company

Now the part about people.

Most people in most companies operate at L1.

They respond to requests. They execute defined tasks, often very well. They escalate when they get blocked.

They are capable, and their output is capped by the quality and the frequency of the direction they get.

The old word for this is order taker. Useful, and limited by design.

A smaller group operates at L3 or L4. They get handed an outcome. They plan. They pick their own approach. They adapt when the ground moves. They come back when it is done or when they are truly stuck.

Founders. A few executives. Certain specialists. Anyone with real end-to-end ownership.

The dials are the same ones:

• An objective instead of a task
• Tools and budget instead of asking whoever controls them
• Permission to iterate without checking in
• Context on what happened before and why
• Clear bounds on what still needs a signature

Most companies are built to produce L1s. L1 is predictable, reviewable, and easy to manage.

Most AI deployments stall at L1 for exactly the same reason.

The failure runs the same way in both cases. You buy capability. You withhold the agency that would make the capability worth anything. Then you decide the capability was oversold.

Here is the uncomfortable part if you are the founder.

If you are the only L4 in the building, you are the constraint. Every outcome routes through the one person allowed to pursue outcomes. That works at six people. At sixty it is a wall.

Raising a person's agency level is the same operation as raising a model's. Give them the goal, the tools, the loop, the context, and the bounds.

Then stop approving every turn.

Start this week

Pick one small workflow you still touch every week. The one that irritates you.

1. Run it at L1 for two weeks and write down what you actually do. The real version, including the decisions you make without noticing you make them.
2. Turn one dial. Give it the outcome and the loop, in the tool you already use. Change nothing else. Watch exactly where it breaks.
3. Fix the definition first. Nine times out of ten the break is a standard you never stated.
4. Add one tool. Read-only first.
5. Move the bound. Go from reviewing every output to reviewing exceptions. Reversible parts only.

By Friday, get it running five steps deep without you.

Then track the one number that matters: steps per touch.

How many actions does the system take between human interventions?

At L1 the answer is one. A working L3 runs somewhere between five and twenty.