TL;DR
- An agent with a prompt and no role is a tool you’ll keep babysitting. An agent with a role, an owner and a ramp-up plan becomes a teammate that moves business outcomes.
- Anthropic’s free course on human-agent teams reads like an operations onboarding manual. Roles, a written goal, gradual release of trust and a weekly retro. Operators have been doing this with people for decades.
- Use the Agent Onboarding Plan: Role, Access, Approvals, 30-60-90, Review. Five parts, one page, and you can start it Monday with the agent you already have.
Anthropic recently put out a free course on building teams where humans and AI agents work side by side. You’d expect architecture diagrams. Instead it reads like a checklist that could have come out of any plant I’ve worked in: write down who owns what, give the new teammate one visible job first, review the work, extend trust a step at a time, and hold a retro every week.
I laughed a little, because this is exactly how you bring a new hire onto a floor 😅
Think about an AI assistant juggling too many jobs at once:
“It doesn’t get overwhelmed, but things fall off its plate. It’s like a person: when they have too much, something is going to fall.”
If an agent drops things the way a person does when it’s overloaded, then it should be onboarded the way a person is.
I spent 18 years operating inside ABB, Pratt & Whitney, Eaton and Bombardier, and a big part of that work was bringing people into operations without breaking anything. Today I run my own business with a team of AI agents, and I onboard every one of them the same way. “I even have an org chart now, and I’m very excited and very proud.” And to be clear: “I still work with humans. It’s not only AI agents.”
A few weeks ago I wrote about The AI Hiring Screen, the five questions I ask before an agent gets a seat on my team. This issue is what comes after the hire: the first 90 days.
I talk about this on Episode 15 of the podcast, where I walk through how I give my agents roles and keep a human in the loop. This issue is the written plan that goes with it.
Why most agents stall after week one
Here’s the pattern I keep seeing with founders and operations leaders.
Someone gets excited, sets up an agent, writes a long prompt, gives it access to everything “so it can be useful,” and lets it run. Week one is magic. Week two, it sends something it shouldn’t have, or it does a task in a way nobody on the team agreed to, or it quietly does thin work because it can’t see the information it needs. By week three, people stop trusting it, and it becomes one more tool somebody has to check.
None of that is a model problem. It’s an onboarding problem.
We would never do this with a person. Nobody hands a new planner the keys to the ERP, the supplier inbox and the company card on their first morning and says “good luck!” On a floor, a new hire gets a role, the access that role needs (and nothing more), a clear list of things they need a sign-off for, a ramp-up plan, and regular check-ins. That structure is not bureaucracy. It’s how you protect the operation while someone new earns trust.
Anthropic’s course says it better than I can:
“Most of these practices were healthy team habits long before agents, but agents make them costlier to skip.”
And there’s a reason it costs more. From the same course:
“Because the rate of task completion on human-agent teams tends to be higher, the cost of misalignment and error is also higher.”
An agent moves faster than a new hire. That means a badly onboarded agent makes mistakes faster too. The onboarding has to come first.
The Agent Onboarding Plan
This is the plan I use. Five parts, the same five I’d use for a person joining an operation.

1. Role: write the job description before you write the prompt
A new hire gets a job description. Your agent should get one too.
“And the beauty of these AI assistants and agents is that you can draft their roles and responsibilities, their job descriptions. I now have it hooked up to my Notion workspace, where I have roles and responsibilities defined.”
Before I set anything up, I write down, in plain language:
- What job it owns. One job, with one owner. Not “help with operations.” Something like “every Monday, reconcile last week’s receipts against the bank feed and flag anything that doesn’t match.”
- Who it reports to. One named person who reviews its work and answers its questions.
- What good looks like. The business outcome this job protects. Clean books at month end. Supplier delays caught before they hit a customer. Not “save time.”
- What it never does. The decisions that stay with a person.
Here’s the operator move: put the agent on the same roster as the people. Anthropic’s course puts it this way:
“Write the roster, agents included. List every recurring job and give each job one owner.”
When I map a process for a client, the first thing I look for is the step nobody owns. That’s where work falls through. Agents make that gap bigger, not smaller, because now two “people” can each assume the other one has it.
That job description then becomes the core of the agent’s instructions. In Anthropic’s own platform course, an agent is defined as “the persona: model, system prompt, and toolset.” The system prompt is the job description. Write it like one.
2. Access: give it what the job needs, and nothing more
On a floor, a new hire gets a badge that opens the doors their job needs. Not every door in the building.
Same with an agent. Give it access to the tools and information its one job requires. That’s it.
There are two sides to this, and both matter:
- Too little access and the agent guesses. The course is direct about it: “An agent without access does thin work, guesses, or makes mistakes.” If the procedure lives in someone’s head or in a private DM, the agent can’t follow it. “For an agent, if it isn’t written down and accessible, it doesn’t exist.”
- Too much access and you’ve created risk you didn’t need. Anthropic’s own deployment guidance for its managed agents recommends giving an agent the smallest set of tools that does the job, and setting a budget on each session.
So the access step is really two tasks. Write down the knowledge the job needs where the agent can read it. Then remove every tool the job doesn’t need.
I hold myself to this, starting with the assistant that watches my inbox:
“I have it logged in with my email just to read and notify me, so I’m good, but you should look into it before you get that app hooked up to your systems.”
Read and notify. That’s the whole badge for that job.
3. Approvals: decide what needs a human yes
Every new hire has a sign-off list. A new buyer can draft a purchase order but can’t release it. A new planner can propose a schedule change but a supervisor approves it.
Think of this list as a table:
“The human approves what needs to get approved, and what can be handed off is a very deterministic table with decisions that can be made by the AI agent.”
Agents need the same list, and the good news is the platforms are now built for it. In Anthropic’s managed agents, each tool can be set to run automatically or to wait for approval. With the approval setting, in their words, “The session pauses and waits for your approval before executing.” Their docs also say plainly: “auto” is not a human checkpoint.
My rule of thumb, straight from operations:
- Anything that leaves the building needs a human yes. Emails to customers or suppliers, payments, posts, orders.
- Anything that changes a system of record needs a human yes at first. Bookkeeping entries, inventory adjustments, CRM updates.
- Anything that only reads or drafts can run on its own. Reports, summaries, reconciliations, drafts.
This is exactly how I run my own team:
“But when an authorization or a money spend needs to happen, that’s when the human comes into place.”
It even applies to my groceries. My assistant builds the list and fills the cart, “but it doesn’t have authorization to go and click the button, because I want to be the one putting in my credit card and not have it just push whatever it wants. So that is the human in the loop: I put myself in that position, to go and review and then approve.”
4. 30-60-90: one visible job first, then widen
Nobody gives a new hire their full scope on day one. You give them one job they can do well, where everyone can see the work, and you widen from there.
The course suggests starting with one visible job, like a morning briefing for the whole team, and having a person review it for the first few days. Then:
“Extend trust a step at a time, per kind of task. After the agent has handled one kind of task well several times in a row, widen what it may do on that task.”
“Per kind of task” is the part most people miss. An agent that’s great at reconciling receipts has not earned the right to email your suppliers. Trust is earned per task, just like on the floor.
Here’s how I’d lay it out:
- Days 1 to 30: shadow and draft. One job. Everything is a draft. A person reviews every output and gives feedback. Build a simple rubric for what “passing” looks like, because the course is right that every task needs one.
- Days 31 to 60: run with checks. The tasks it has passed several times in a row now run on their own. Anything new or anything that leaves the building still waits for approval.
- Days 61 to 90: own the job. The agent owns its job end to end, with human approval only on the decisions you said stay with people. Now you can think about a second job.
Notice what this looks like from the outside. It looks slow. It isn’t. It’s the same reason we train people before we put them on a critical line: you’re buying a teammate you can actually trust in month three.
5. Review: a weekly retro, written down
A good supervisor holds a weekly one-on-one with new people. What went well, what didn’t, what’s unclear.
Do the same with your agent. Once a week, look at what it did. What did it get right? Where did you have to step in? What did you have to explain twice? The course has a great line for that last one: “When you explain the same thing twice, turn it into written instructions for the agent.”
Then write the lessons down where the agent will read them next time. That’s the loop in the diagram: every review updates the job description. The course even suggests asking agents to save these retros “so other agents can use them later.” That’s institutional knowledge, built the same way we build it with people.
What this looks like in practice
I’ll give you one from my own team.
I have an agent whose job is to check my receipts and expenses every week. One job, one owner (me), read access to what it needs, and it drafts, it doesn’t move money. Another agent keeps my business plan updated and flags anything that looks off.
Because they were set up this way, they found about $200 in expenses I could cut. That’s a business outcome. And I trust the finding, because I know exactly what the agent could see, what it was allowed to do, and how its work gets reviewed.
And one more:
“The other one is Taylor, whose only job is to look at all my open actions and match them to see if I have closed them, based on my emails, my meetings and things like that. If I haven’t closed anything, it’s Taylor’s job to let me know.”
One job, one owner, and its output is a nudge to me, not an action. That’s the whole Agent Onboarding Plan in a single agent.
That’s a business outcome too: the commitments I make in meetings don’t quietly slip, because Taylor tells me before they do.
If you want proof that this scales well beyond a solo business, look at Shopify. In a recent engineering post about their in-house agent, they explain that back in spring 2024 they made two unpopular infrastructure moves, putting everything they ship into one repository and making their environments reproducible, on the bet that “Code is going to be increasingly written with AI, and our infrastructure needs to be the substrate for that.” Their summary of what happened: “It was painful. And it worked.” Today they report that one in eight merged pull requests across the company is coauthored by that agent.
That’s an engineering story, but the operations lesson is the same one I’ve been teaching for years: map the whole process and put the knowledge where everyone can reach it, before you automate a piece of it. “Make sure that you’re looking at the process first, not just adding the AI agent.”
SAVE THIS
The Agent Onboarding Plan
- Role. One job, one owner, one business outcome, and a written list of what it never does.
- Access. The knowledge the job needs, written down where the agent can read it. The smallest set of tools that does the job.
- Approvals. Anything that leaves the building or moves money waits for a human yes.
- 30-60-90. One visible job first. Widen trust per task, only after it passes several times in a row.
- Review. A weekly retro. Every lesson goes back into the job description.
Your Monday morning
- Pick the one agent (or the one AI tool) your team already uses. Write its job description on one page: the job, the owner, the outcome, the never-do list.
- Audit its access. List every tool and system it can touch. Remove anything the job doesn’t need.
- Write your approval list. Three columns: runs on its own, needs a yes, never. Set the approvals in the tool, not just on paper.
- Put a 30-minute weekly review on your calendar. Same day, same time, like a one-on-one. Bring the outputs and your notes on what you had to explain twice.
You wouldn’t let a new hire run without a role, a ramp and a review. Your agent deserves the same onboarding, and your operation needs it.
If you’re going to use this framework, I want to hear about it. Reply and tell me what you’re working on.
If your agent started on Monday, who would own its first 30 days?
P.S. You’re already the person who fixes how things work. Bring a real problem from your work, and in 8 weeks you’ll fix it with AI as a Forward Deployed Operator. FDO School opens soon.