Human-in-the-Loop in Practice: Offboarding, Before and After

I spend most of my time in the messy middle — the gap between "the demo worked" and "we let it touch production." So let me not theorize. Let me walk you through one Tuesday at a company running a StudioX offboarding Mission inside their own perimeter, before and after, with the numbers we actually measured.

The before: a contractor who never left

A contract ends on Friday. In the old world, here is what was supposed to happen: the manager files a ticket, IT revokes the accounts, security confirms the VPN cert is dead, finance closes the PO. In practice, the ticket sat. The contractor's GitHub access, their VPN profile, their access to a customer data store — all of it stayed live. Nobody noticed until the annual audit flagged an account that had authenticated 40 days after the contract's end date.

That is not a hypothetical. That specific pattern — "contract expires, access doesn't, nobody notices until the audit" — is the single most common finding I see. The average dwell time between a contractor leaving and their access actually being cut, at the organizations I've assessed, was north of three weeks. Every day of that is unmanaged risk sitting on your books.

The instinct is to automate the revocation. Just have a script kill everything the moment the contract end date passes. And for the low-stakes accounts, fine. But "kill everything" is exactly the action you do not want a machine doing unsupervised, because the day it misfires on a full-time employee who happened to share a project code, you have locked a person out of their job and possibly triggered an incident of your own making. Revocation is destructive and irreversible. It is the textbook case for a human gate.

The after: one Tuesday, watched end to end

Here is the same Friday, run as a StudioX Mission. I'll narrate it the way it appeared to the reviewer.

At 9:02, the Mission picks up the contract-end signal. The router hands the goal to the offboarding agent. On the Explain rail, I watch it happen in real time: the agent discovers what tooling it has, plans its steps, and queries — across the identity system, the VPN, the code host, the finance system — for everything tied to that contractor. Each tool call and its result stream onto the rail as an observation. By 9:03 it has assembled the full picture: eleven active grants across four systems, one of which is elevated access to a customer data store.

Then it stops. It does not revoke anything.

Because revocation is high blast-radius, the Mission emits an approval request instead of acting. In the same moment, three concrete things happen behind the scenes: a decision-queue row is created, the reviewer — the contractor's manager — gets an email with a magic link, and the chat view shows an "Awaiting approval" status rather than a false "done." The manager opens the link at 9:15. And this is the part that matters: they are not staring at a naked yes/no. They see the eleven grants, which systems, the elevated one flagged, and the reasoning trace of how the agent found them. They are briefed.

They approve ten and hold the elevated one for a quick word with the data-store owner. Two minutes later they approve that too. The Mission executes the revocations, each one traced, and the decision-queue row records who approved what and when. Total wall-clock: the contractor is fully deprovisioned before lunch, with a human signature on every irreversible action and a clean audit line.

The ROI, honestly

Let me give you the arithmetic, because "faster" is not a business case.

Before: 21-day average dwell time on unrevoked access, and roughly two hours of scattered human coordination per offboarding across three teams — most of it chasing, not deciding. Multiply by a workforce with heavy contractor churn and you have both a standing risk exposure and a real labor cost.

After: dwell time collapses to the same morning. The human effort drops to a single reviewer spending about four minutes on the one thing that genuinely needs judgment — the elevated grant. Everything else the Mission gathered and staged. We did not remove the human. We removed the chasing and kept the deciding. That is the whole trick. The two hours of coordination became four minutes of judgment, and the 21-day window became zero.

And the audit story flips completely. Instead of explaining why an account lived 40 days past a contract, the security team has a decision-queue record showing exactly who approved each revocation, what they saw, and when. When a regulator asks "who authorized this," there is a name and a timestamp, not a shrug.

What makes it hold up in the field

Two things, and I say this as the person who has to sign off before any of it goes live.

First, the gate is unskippable by construction, not by policy. Because a destructive action produces an approval request instead of a silent call, there is no code path where the machine quietly does the scary thing. You do not have to trust that someone remembered to add a check.

Second, it runs inside your perimeter. The agents, the reasoning trace, the decision queue, the emails — all of it sits where your data already lives, which is the only way a security team will ever let automation near production systems. That deployment posture is its own subject, and I'd point you to enterprise deployment for how we lock it down.

The pattern generalizes far past offboarding — refunds, access grants, config changes, anything destructive or irreversible. Wherever the cost of a wrong autonomous move is high, you put a briefed human at exactly that moment and nowhere else.

For the leadership framing of why this beats both full autonomy and bolted-on approvals, read Ajay's why it matters. And if you want the wiring underneath everything I just described, Mark's how it works is the map.