TL;DR


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.

The Agent Onboarding Plan: Role, Access, Approvals, 30-60-90 and Review, with a loop from Review back to Role to update the job description

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:

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:

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:

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:

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

  1. Role. One job, one owner, one business outcome, and a written list of what it never does.
  2. Access. The knowledge the job needs, written down where the agent can read it. The smallest set of tools that does the job.
  3. Approvals. Anything that leaves the building or moves money waits for a human yes.
  4. 30-60-90. One visible job first. Widen trust per task, only after it passes several times in a row.
  5. Review. A weekly retro. Every lesson goes back into the job description.

Your Monday morning

  1. 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.
  2. Audit its access. List every tool and system it can touch. Remove anything the job doesn’t need.
  3. Write your approval list. Three columns: runs on its own, needs a yes, never. Set the approvals in the tool, not just on paper.
  4. 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?

Contact us

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.

Join the waitlist