Don’t outsource work to AI. Offboard it.

Most companies talking about “giving work to AI” are describing outsourcing without realising it. A task that used to belong to someone gets pointed at a model or an agent, the person moves on to something else, and six weeks later nobody can say with any confidence who owns the output, what the agent was actually told to do, or what happens when it gets something wrong. The work did not go away. The accountability did.

We think the better word is offboarding. Not in the HR sense of someone leaving, but in the sense every good engineering team already understands: you do not hand a system to a new owner by throwing it over the wall. You write down what it does, you walk them through the edge cases, you shadow them for a while, you agree who gets paged when it breaks, and you keep the ability to take it back. Offboarding a task to an agent should work the same way. The task moves. The human stays in the loop, on purpose, by design.

Outsourcing and offboarding look the same on day one

That is what makes the distinction easy to miss. In both cases a task that a person used to do is now done by something else, and the first week’s demo is identical. The difference only shows up later, in four places.

• Context. Outsourcing sends the task and keeps the context in someone’s head. Offboarding writes the context down — the rules, the exceptions, the “we never do this for enterprise customers” — so the agent works from the same knowledge the person did, and the next person can read it.
• Scope. Outsourcing says “handle invoices.” Offboarding says “match invoices under a set value against purchase orders, flag mismatches, never approve payment.” The boundary is explicit, and so is what sits on the other side of it.
• Accountability. Outsourcing quietly assumes the agent is responsible. Offboarding names a person who owns the outcome, reviews the work, and answers for it. Agents do not carry accountability; people do. A process that pretends otherwise has simply lost track of who is accountable.
• Reversibility. Outsourced work is hard to take back because the people who knew how to do it have moved on and nobody wrote anything down. Offboarded work can be pulled back to a human in an afternoon, because the handover documentation is the same material a person would need.

None of this is exotic. It is the discipline teams already apply when a service changes hands between squads, or when a senior engineer rotates off a critical system. The mistake is assuming that because the new owner is software, the handover can be skipped.

What “human in the loop” actually means in practice

“Human in the loop” has become a phrase people say to end a meeting rather than a design they build. Too often it means a person is technically able to look at the agent’s output and in practice never does, because the review queue is a thousand items long and approving everything is the only way to keep up. That is not a loop. It is a rubber stamp with extra steps.

A real loop has a few properties you can check for. The human sees the decisions that matter, not every decision — which means the agent has to be built to know the difference and escalate the ambiguous, high-value, or irreversible cases. The human can see why the agent did what it did, not just what it produced. The human’s corrections flow back into the agent’s instructions or eval set, so the same mistake does not arrive in the queue next week. And the level of oversight is set per task and adjusted on evidence: tight at the start, looser as the agent earns trust, tight again the moment its error rate moves.

Put differently: offboarding is a gradient, not a switch. A task might start with the agent drafting and a person approving every item. After a month of clean results it moves to the agent acting and a person sampling one in ten. Some tasks stay at the first level forever, because the cost of a wrong answer never justifies anything looser. The point is that someone decided, deliberately, where each task sits — and can move it.

The infrastructure the handover needs

Here is the uncomfortable part. Offboarding well is not mainly a mindset. It needs plumbing, and most teams do not have it. The reason so much AI adoption drifts into outsourcing is that the infrastructure for a proper handover was never built, so the path of least resistance is to wire a model in and hope.

• A handover spec for every task. What the agent does, what it must never do, which systems it may read and write, and what a correct outcome looks like. This is the document a human would need to take the task back — and it is the same document the agent’s instructions are built from.
• Review gates in the workflow, not beside it. Approval steps that sit inside the tools people already use, routed to the named owner, with the agent’s reasoning attached. If reviewing means opening a separate dashboard, it will not happen.
• Escalation rules the agent actually follows. Thresholds for value, confidence, and irreversibility that send a case to a person instead of acting on it. Written down, tested, and visible to the humans who receive the escalations.
• Identity and permissions per agent. Each agent acts under its own identity with the narrowest access its task needs, so you can see which agent did what and revoke one without breaking the others. A shared service account makes accountability impossible by construction.
• An audit trail you can replay. Every action, the inputs it saw, and the human decisions around it, kept in a form someone other than the builder can read. When a customer or an auditor asks why something happened, “the AI did it” is not an answer.
• Evals that tell you when to tighten the loop. A standing test set per task, run continuously, so a drop in quality shows up as a number before it shows up as a complaint — and oversight can be increased on evidence rather than after an incident.

And underneath all of it, people who know how to work this way. The most common failure we see is not a bad agent. It is a team that was given agents without being taught how to write a handover spec, how to review agent output efficiently, or how to decide when a task is ready for a looser loop. Building that capability is the core of an AI Enablement engagement: we set up the handover templates, review gates, escalation rules, and runbooks with your team, on the tools you already use, and train the people who will own each offboarded task so the discipline outlasts our involvement.

The honest counter-argument

There is a fair case that this is too much ceremony. For plenty of low-stakes work — summarising a meeting, drafting a first pass at release notes, tidying a spreadsheet — a full handover spec, a review gate, and an eval set are overkill, and insisting on them will slow adoption to the point where the team gives up and uses AI informally anyway, with no controls at all. Heavy process can push people towards shadow AI faster than no process. And there is a real argument that some tasks genuinely should be outsourced in the full sense: fully automated, no human watching, because the cost of a mistake is trivial and a person reviewing it is a waste of that person.

We agree with most of that. The answer is proportion, not uniformity. The weight of the handover should scale with the cost of getting it wrong: a single line of scope and an owner’s name for the trivial tasks, the full apparatus for anything that touches customers, money, or a system of record. And “fully automated” is itself an offboarding decision — the loosest point on the gradient — as long as someone made it deliberately and can reverse it. What we would push back on is the default we see most often, where nobody decided anything and the loop quietly disappeared.

What to do in the next 30 days

• Inventory what has already been handed to AI. Formally or informally. For each task, ask the four questions: is the context written down, is the scope explicit, is there a named owner, and could a person take it back tomorrow?
• Pick one task and offboard it properly. Write the handover spec, set the review gate, define the escalation rules, and agree the starting level of oversight. Use it as the template for the rest.
• Give every agent its own identity. If your agents share credentials, fix that before adding more of them.
• Train the owners, not just the builders. The people reviewing agent output need to know what good looks like and how to feed corrections back. That skill is what keeps the loop real.

The companies that get the most out of AI over the next few years will not be the ones that handed off the most work. They will be the ones that handed it off well — with the context written down, the boundaries explicit, a person accountable for every outcome, and the ability to take any task back when it matters. Outsourcing to AI is fast and leaves you exposed. Offboarding to AI takes a little longer and leaves you in control.

Handing work to agents and not sure who is still accountable for it? Talk to Cravings about AI Enablement — we build the handover specs, review gates, escalation rules, and per-agent audit trails with your team, and train the people who own each task so the human stays in the loop by design.