Managing agents like new employees
The manager metaphor — how onboarding, delegation, and oversight transfer to AI agents.
You already know how to do this
"In a lot of ways, the IT department of every company is going to be the HR department of AI agents in the future." — Jensen Huang, CEO, NVIDIA — CES 2025 keynote, 6 January 2025. Source
Microsoft's 2025 Work Trend Index makes the individual-level version of the same point: every knowledge worker is becoming an agent boss — someone who "builds, delegates to, and manages agents to amplify their impact." (Microsoft WorkLab, 23 April 2025)
Take that framing seriously. If managing a team of agents is becoming a core professional skill, the richest mental model you already have — managing a new employee — transfers almost directly. You have done onboarding. You have delegated. You have reviewed work and given feedback. The moves are the same; the apprentice is just faster and more literal.
This lesson is the key intuition for the rest of the Design pillar. The Agent Canvas, REMIT, and the oversight-model lessons in the Govern pillar are the formal version. The manager metaphor is the informal version you can hold in your head in a meeting.
Four moves you already make
When a good manager brings on a new hire (a graduate, a contractor, an intern) they do four things, mostly without thinking:
- Define the job. Not "help the team", but a specific outcome, for a specific user, with specific "DO NOT" items.
- Set boundaries. What systems can they touch? Who approves what? When must they escalate?
- Check in. Daily for the first week. Weekly after that. Sampled after trust builds.
- Review and grade. Not on activity but on outcomes. With a clearly communicated rubric. Fairly and candidly.
All four map onto designing an agent. The Canvas cells are literally this list reformatted.
The mapping
| New employee move | Agent equivalent | Canvas cell |
|---|---|---|
| Write a job description (the real one, not the recruitment one) | Purpose & Job-To-Be-Done | Purpose |
| Give them a work email, logins to app they need, and limited system access | Risk-rate and wire tools | Tools |
| Tell them what's in scope, what and when to escalate, and who to escalate to | Guardrails & explicit "NOT for" list | Guardrails |
| Define their starting authority | Observe → Recommend → Act-with-Approval etc. | Authority |
| 1:1s, code reviews, sampled call reviews | Human checkpoints; review sampling | Human Checkpoints |
| Tell them which metrics and OKRs their performance rolls up to | Define the success metrics upfront | Success Metrics |
| Promote when they've earned trust; demote when they haven't | Graduated autonomy; demotion on failure | Authority (over time) |
If you find yourself unable to answer one of the left-hand questions for a human new hire, you are not ready to answer it for an agent either.
What changes at agent scale
The metaphor breaks in three places — worth knowing up front, because these are the places governance work lives.
- Volume. A new hire handles ten tickets a day. An agent handles ten thousand. Approving every agent action the way you'd approve a junior's first week burns your reviewers out in a morning — the pathology called approval fatigue. The fix is sampling and architecture, not more approvers.
- Instinct. A junior who feels uneasy pauses and asks. An agent does not feel uneasy. It confidently ships a wrong action at the same rate it ships a right one. You have to design in the moments where it stops and asks.
- Memory and identity. A human carries context between tasks and between days. Agents, by default, don't — and when they do, it's configurable memory that raises its own governance questions. Context engineering (covered in the Build pillar) is the prosthesis.
These three gaps are what drive the three human-oversight architectures — HITL / HOTL / HOOTL — that you'll meet in the Govern pillar. Each one is a different answer to when the manager stays in the loop:
- HITL — the agent proposes, you approve each action. (First-week junior.)
- HOTL — the agent acts, you monitor in real time and can pull the cord. (Junior two months in.)
- HOOTL — the agent acts, you audit after the fact. (Senior colleague you trust.)
The architectural details — system shape, infrastructure, failure modes — are in the oversight architectures lesson. What matters here is that promoting an agent through these tiers is the same move as promoting a human — earned with evidence, reversible on failure.
The intern heuristic
Ethan Mollick's rule of thumb, from Co-Intelligence (Portfolio/Penguin, 2024):
"The best way to work with [AI] is to treat it like a person… Talk to it like an employee, like an intern, and you'll get a large part of the way there. And on top of that, tell it what kind of person it is." — Ethan Mollick, Wharton. (Knowledge@Wharton interview)
The intern framing is load-bearing. An intern:
- Needs the brief written down, because they have no tacit context.
- Does exactly what you ask — including the parts you didn't mean.
- Produces confident-looking work that needs checking.
- Gets better fast if the feedback loop is tight.
- Should not be given the corporate credit card on day one.
Every one of those maps directly to an agent design decision.
Where this takes you
Hold the new-employee frame through the rest of Design:
- The Agent Canvas is the formal version of the onboarding pack.
- Problem framing is the job description interview you conduct with the hiring manager before you write the pack.
- Getting started is the first-week plan.
And through Govern:
- HITL / HOTL / HOOTL are the three oversight rhythms.
- Authority levels are the promotion ladder.
- REMIT is the performance-management system wrapped around all of it.
You are not learning a new management discipline. You are applying the one you already have, to a workforce that scales differently.