A widely shared delegation checklist asks six questions before you hand off a task: what the person already knows, why the task matters, what they need to do it, what “great” looks like, the timeline and priority, and what could go wrong. Applied to an AI agent instead of a person, three of those questions matter even more than they used to. Three stop being the right question entirely, because an agent never pauses mid-task to say “I’m not sure about this part, can you clarify.”
It’s a genuinely good checklist. I’ve used versions of it for years: briefing a new assistant, prepping a co-speaker before a joint keynote, bringing someone into a project mid-stream.
This month I ran the same six questions against my own AI agents, the ones that draft blogs from keynote notes, research competing speakers, and manage pieces of my content pipeline. Three of the questions got sharper. Three stopped making sense and needed to be rewritten from scratch.
If you’re delegating anything to an AI agent this year, and most leaders now are, this is the version of the checklist that actually holds.
The three questions that get “sharper”, providing more context
1. “Why are we doing this?” matters more with an agent
With a person, you share the purpose behind a task so they can make good judgment calls when you’re not in the room. Skip it, and a competent employee usually still lands somewhere reasonable, because they’re reading the situation with the same instincts they use everywhere else in their life.
An agent doesn’t have those instincts. It optimizes for exactly what you told it to optimize for, and nothing else. Tell it to “clean up my inbox” and it might archive things you needed. Tell it to “increase engagement on this post” without telling it the post exists to book keynotes, not to go viral, and it will happily draft something loud and empty. The purpose isn’t only context. It’s the only thing stopping the agent from succeeding at the letter of the task while failing the point of it.
The fix: state the outcome you actually want, not just the action, every time you hand a task to an agent.
2. “What do they need to do this?” becomes a permissions question, not a resources question
For a person, this question is about mise en place: give them the login, the file, the introduction to the right colleague, before they start, not mid-task. For an agent, “what they need” is narrower and more literal: exactly which tools, which systems, which data it’s allowed to touch.
The difference that matters: a person who’s missing access will usually stop and tell you. An under-provisioned agent often won’t. It routes around the gap, improvises with what it has, or produces a confident-looking answer built on an assumption instead of the real data. You find out after the output is already in front of a client.
The fix: scope access and tools before the task starts, not as a fallback once something breaks.
3. “What does great look like?” needs a rubric, not a role model
WIth people the advice here is to show, not tell: share mockups, examples, screenshots. That still applies to agents, but the reason it matters has changed. A person builds taste over years on the job, in a way that quietly fills the gaps between your examples. An agent has no such reservoir. It pattern-matches only what’s in front of it.
Vague quality bars that a seasoned employee could infer (“make it sound like us,” “keep it professional but warm”) mean almost nothing to an agent. It needs the standard spelled out as something it can check its own work against: length, words to use and avoid, a good and a bad example side by side.
The fix: give the agent a checklist it can grade its own output against, not just a vibe.
The three questions that need a different question entirely
4. Don’t ask what it knows. Assume it knows nothing, until you’ve built its memory.
The question is about calibrating to what someone already understands, so you’re not over-explaining or under-explaining. With an agent, that calibration used to have nothing to calibrate to. Most agents started every task with no memory of the last one, no sense of your company’s politics, no radar for “this isn’t how we normally do things here.”
That’s changing fast. Claude Code, Cowork, and ChatGPT Codex have all made real strides on persistent memory, project context, and reusable skills, so a properly set up agent doesn’t have to relearn your codebase, your brand voice, or your standing rules from zero every single time. The blank slate hasn’t disappeared. It’s moved: from “the agent knows nothing” to “the agent knows only what you deliberately taught it to remember.”
The dangerous part was never the blank slate itself. People start blank too. The dangerous part is what an under-taught agent does about the gap: a person who’s missing information usually pauses and asks. An agent fills it with a plausible-sounding guess and delivers it with the same confidence as a fact it actually knows. It will not volunteer “I’m not sure about this part.”
The fix: stop re-briefing from scratch every time. Invest once in the agent’s memory, project files, and skills, then only add what’s genuinely new to each brief. If something matters and it isn’t already in there, write it down, because nothing carries over that you haven’t deliberately made carry over.
5. “Timeline and priority” isn’t the real question. “How much “rope”, freedom and autonomy” is.
Urgency language does real work on a person. Tell someone a deadline is tight and they focus harder, cut corners more deliberately, escalate sooner. An agent doesn’t feel time pressure. It doesn’t work faster because you wrote “URGENT” in the brief, and it doesn’t get tired on a long task the way a person does at 6pm on a Friday.
What actually matters for an agent is autonomy, not urgency: how many steps can it take before it checks in with you, should it stop and ask when it hits something ambiguous, or keep running to the end regardless. Skip this question and you get one of two failure modes: an agent that pings you after every tiny decision, or one that runs twelve steps past the point where a person would have stopped to check.
The fix: replace “when do you need this” with “how far can it go before it checks back in with me.”
6. Don’t just name what could go wrong. Build the guardrail into the task.
For a person, naming the risk is usually enough. Tell someone “don’t send this without me seeing it first” and they remember, because they understand consequences and don’t want to be the one who broke something.
An agent doesn’t have that self-preserving instinct. Naming a risk out loud doesn’t automatically stop it from happening, because the agent isn’t weighing consequences the way a person does. It takes the action the task calls for, unless a hard stop is built into the instructions themselves. It also won’t reliably notice when it’s out of its depth and escalate. Left alone, it keeps going with the same confidence whether it’s right or badly wrong.
The fix: turn every risk you name into an explicit checkpoint. “Draft this, then stop and show me before sending” is a guardrail. “Be careful with this” is not.
Keynote with Prologis Management Team – global leader in logistics
Three questions get more important with an agent: why, access, and the quality bar. Three questions stop being the right question entirely: what it knows becomes build its memory first, the timeline becomes how much rope, and what could go wrong becomes where’s the checkpoint.
Delegating to a person is about transferring judgment. Delegating to an agent is about engineering the boundaries that judgment would normally provide. Different job, same six-question habit.
FAQ
Can you use the same delegation checklist for AI agents as for people? Partly. The habit of asking questions before handing off a task still applies, but three of the six questions (what it knows, the timeline, and what could go wrong) need to be rewritten for agents rather than reused as is.
What’s the biggest mistake leaders make when delegating to AI agents? Treating a lack of pushback as a lack of problems. An agent that doesn’t ask clarifying questions isn’t confirming it understood the task. It’s filling gaps with guesses and moving forward regardless.
Does an AI agent need to know why a task matters, not just what to do? Yes, arguably more than a person does. Agents optimize literally for whatever you told them to optimize for. Without the underlying purpose, they can satisfy the instruction while missing the point of it entirely.
How do you set boundaries for an AI agent’s access to tools and data? Scope exactly which tools, systems, and data the agent can touch before the task starts, not as damage control after something goes wrong. An agent that’s missing access rarely stops to tell you.
What happens if you don’t tell an agent what could go wrong? Naming the risk out loud isn’t enough on its own, the way it often is with a person. The safeguard needs to be built into the task as an explicit checkpoint, or the agent has nothing stopping it from taking the risky action anyway.
This is the same principle behind everything I teach leaders about building human and AI teams: the tools change fast, but the discipline of leading well doesn’t. The future belongs to Human and AI teams that know exactly which of their old habits still apply, and which ones need to be rebuilt.
If you’re building your own playbook for delegating to AI agents, this is also the territory covered in the keynote “Leading Human and AI Teams” and on the Virtual Power Team Podcast.
Peter Ivanov is a keynote speaker and executive coach on Leadership in the Age of AI, working with leadership teams on building high-performing Human and AI Teams.
