The Situational Leadership Curve, Applied to Agents
Good managers stopped asking 'is this person ready?' decades ago. The better question is 'ready for what?' That question is missing from most agent oversight, and it changes how much rope an agent should get.
Part 3 of the Managing Agents Like People series. New to the series? Start with Part 1: Managing Agents Is Like Managing People.
The Right Question Is "Ready for What?"
Most conversations about AI agent oversight start with the agent. Is it reliable? Do we trust it? Those questions sound reasonable, and they lead to policies that are too tight on some tasks and too loose on others, at the same time.
Management had this problem long before agents existed. A manager who asks "is this person ready for more autonomy?" gets a vague answer, because the honest response is almost always "on some things, yes; on others, not yet." One of the most widely taught frameworks in management, Paul Hersey and Ken Blanchard's Situational Leadership model, is built on that observation. It doesn't rate people. It rates a person's readiness on a specific task, and it prescribes a leadership style to match.
In Managing Agents Is Like Managing People, I argued that the delegation discipline good managers already use transfers to agents. This post makes that concrete. Situational Leadership maps onto agent oversight almost literally, and it supplies the vocabulary that most oversight policies are missing.
Four Stages, Four Styles, Four Oversight Modes
Hersey and Blanchard's original model dates to the late 1960s. The version most managers encounter today comes from Blanchard's later refinement, now called SLII, which describes four development stages and pairs each with a style. The styles differ along two dimensions: how much direction the leader gives (what to do, how, when) and how much support the leader gives (encouragement, listening, involvement in decisions).
- Enthusiastic beginner (low competence, high commitment) gets directing: lots of direction, little need for support.
- Disillusioned learner (some competence, dipping commitment) gets coaching: lots of direction and lots of support.
- Capable but cautious contributor (high competence, variable commitment) gets supporting: less direction, plenty of support.
- Self-reliant achiever (high competence, high commitment) gets delegating: little of either, because neither is needed.
Drawn on a chart, the four styles sit side by side with a bell-shaped curve running through them: as someone develops on a task, the right style travels along the curve from directing to delegating.
Here's how each style translates when the worker is an agent:
| Leadership style | Agent oversight mode | What it looks like in practice |
|---|---|---|
| Directing | Approve every step | A human approves each tool call or action before it executes. Instructions are explicit and narrow. |
| Coaching | Approve milestones, require reasoning | The agent works in stages and explains its reasoning at each checkpoint. A human reviews the plan and the intermediate results, not every keystroke. |
| Supporting | Spot-check and stay available | The agent runs on its own. A human samples outputs and is reachable when the agent escalates something it's unsure about. |
| Delegating | Review the outcome only | The agent owns the task end to end. A human verifies results against a definition of done, on a cadence. |
An agent that categorizes incoming support tickets might start with a human approving every label (directing), move to a human reviewing each day's batch along with the agent's reasoning on ambiguous tickets (coaching), then to a weekly sample plus a queue for tickets the agent flags as unclear (supporting), and eventually to a monthly check of routing accuracy (delegating). The work is identical across all four. Only the oversight changes.
What "Commitment" Means When the Worker Is Software
The model's second axis, commitment, is about motivation and confidence. Agents don't have morale. Thoughtworks recently argued that frameworks like this one were "engineered for a workforce that experiences fatigue, requires motivation and exists as single entities." That's fair as far as it goes. But it doesn't mean half the model falls away. It means it needs translating.
For an agent, the closest equivalent to commitment is consistency: does the agent behave the same way on the hundredth run as on the first, and does it handle the cases it can't resolve by flagging them rather than guessing? That's the part of a person's commitment a manager actually relies on.
Seen that way, the disillusioned learner stage is the most dangerous one for agents, just as it's the trickiest one with people. Early on, an agent's mistakes are obvious and everyone is watching. A bit later, its output is good enough to look right most of the time while still being unreliable on the cases that matter. That's exactly when teams are tempted to relax, and exactly when coaching-style oversight, with checkpoints and the agent's reasoning visible, catches the problems that a quick glance at the output won't.
The capable but cautious stage has an agent equivalent too: an agent that does the work well but hedges, over-escalates, or asks for confirmation on things it handles correctly. The supporting style fits that stage, for agents as for people. Stay available, answer the escalations, and use them as evidence for whether the task is ready to be handed over fully.
The Curve Is Per-Task, Not Per-Agent
This is the part of the model that matters most, and the part most agent policies miss.
Situational Leadership never says a person is a self-reliant achiever. It says a person is a self-reliant achiever on this task. A senior accountant can run month-end close in their sleep and still be an enthusiastic beginner the first time they're asked to evaluate a new ERP system. A good manager delegates the first and directs the second, on the same afternoon, to the same person, without anyone finding it strange.
Agents are no different. The same agent, running the same underlying model, can reliably reconcile invoices against purchase orders and be completely unproven at drafting replies to vendor disputes. Its track record on one task says very little about the other. Anyone who builds agent workflows runs into this quickly: an agent that has earned a long leash on one job needs a short one the moment you hand it a genuinely new one.
That makes agent-level oversight policies a category error. "This agent is trusted" and "this agent requires approval" both attach readiness to the wrong thing. The unit that has a stage is the task, or more precisely the pairing of an agent with a task. Oversight should be set and reviewed at that level.
That's where this differs from the autonomy frameworks now emerging for agents. The Knight First Amendment Institute's Levels of Autonomy for AI Agents defines five roles a person can play, from operator to observer, and treats autonomy as a design decision for the agent. Situational Leadership adds what that leaves out: the level belongs to the task, and it moves.
Movement Runs in Both Directions
People move backward on the curve, and good managers expect it. A reorg, a new system, or a change in what "done" means can push a confident employee back to needing hands-on coaching for a while. That isn't a demotion. It's an honest response to changed conditions.
Agent tasks regress for the same kinds of reasons, often more abruptly:
- A model upgrade. A newer model may be better overall and still behave differently on your task. The track record was earned by the old one.
- A prompt or instruction rewrite. Changing how a task is specified changes the task, even if the name stays the same.
- An upstream change. A new CRM field, a reformatted report, or a changed vendor email template can turn a well-understood task into an unfamiliar one.
- One bad outcome. A single confident, wrong result on something that matters is evidence. It's reasonable to drop the task back a stage until the cause is understood.
A stage isn't a permanent label. It's a current reading, and changes like these should trigger a fresh one.
Mismatched Style Is the Real Failure
The model's core warning is about mismatch, and it cuts both ways.
Directing a task that's ready for delegation is expensive. Throughput drops to whatever the reviewer has bandwidth for, the reviewer's attention gets spent on work that didn't need it, and the agent never builds the evidence that would justify more autonomy. With people, the same pattern drives good performers away. (Part 2, The Agentic Micro-Manager: What Gets Lost When You Approve Every Step, covers that cost in full.)
Delegating a task that still needs direction fails differently, and usually more quietly. Nobody is watching closely when the agent hits the case it doesn't understand, so the mistake surfaces later, downstream, and at a higher cost to fix.
Neither failure is about too much or too little oversight in the abstract. Both come from oversight that doesn't match the stage of the task. Situational Leadership doesn't resolve the tension between keeping a human in the loop and learning to let go by picking a side. It resolves it task by task.
Name the Stage Before You Set the Oversight
The most useful habit this model offers is simple: before deciding how closely to watch an agent on a task, say out loud which stage that task is at, and why.
"New task, no track record" means directing, regardless of how capable the agent seemed in the demo. "Solid results, but we haven't seen the edge cases yet" means coaching. "Reliable, and it flags what it can't handle" means supporting. "Months of clean outcomes, and we verify results on a schedule" means delegating. Each answer comes with evidence, and the evidence is what lets the task move up a stage, or back down one, when conditions change.
None of this removes the human from accountability. In every stage, including delegating, someone still owns the outcome and checks it. What changes is where their attention goes: on the steps when the task is new, and on the results once it has earned that.
Subscribe for more like this.
In the spirit of this site: this article was drafted with AI assistance and edited by Matt before publishing — the same kind of human-in-the-loop review this piece argues for.
About the Author: Matt Shirel writes Praxis CTO, exploring what real technology leadership looks like for growing companies that have outgrown ad hoc decision-making. He brings over 20 years in enterprise IT — spanning infrastructure architecture, cloud strategy, and technology budget ownership — and works hands-on in applied AI, building multi-agent and RAG workflows with tools like n8n and AI coding agents — work where the same agent regularly needs a long leash on one task and a short one on the next.
