The whiteboard is done. The room finally agreed on the ugly version of the path. Someone photographed the board. Someone else said the quiet part out loud: “Great. Now let’s put an agent on it.”
That sentence is where a lot of mid-market AI programs go sideways.
The last piece said map it first: draw the real path, including workarounds, before you model anything. This piece is the third move. Not another argument for mapping. The day after the map: how to turn a whiteboarded workflow into an agent surface without handing a broken handoff a bot and calling it progress.
Don’t give a broken handoff an agent.
The day after the map
Here’s what I’ve seen after a good whiteboard session.
The energy is real. People finally named the shadow tracker. They circled the access gap. They marked the exception that only one person knows how to clear. For a few hours the organization is honest about how work actually moves.
Then the old habit returns, dressed as urgency.
Someone wants a pilot name. Someone wants a vendor demo. Someone wants to “agent-ify the process” before access rights get fixed, before the spreadsheet stops being the system of record, before the exception path has a backup owner.
The map did its job. The organization skips the boring part: stabilize, then choose a thin surface.
I’ve sat in that room the morning after. The conversation drifts from “we finally see the path” to “what model should we use” in under ten minutes. That drift is the tell. The map became a permission slip to automate, not a diagnosis of what still can’t be trusted.
Thesis: the agent surface is thinner than you want
An agent surface is the thin slice of a mapped workflow where rules-plus-judgment can be delegated without lying about the system of record.
Thin slice. Not the whole swim lane. Not “AI owns AP.” Not “the bot runs exceptions.”
Rules-plus-judgment means: given clean inputs and a named rule, the agent can draft, route, gather, watch, or flag. A human still owns the call when the rule doesn’t fit. Without lying about the system of record means: the agent reads and writes the place where truth actually lives, not the place the SOP pretends is true while everyone updates a personal tracker.
If your truth still lives in a shadow spreadsheet, an agent pointed at the ERP is a story with an API key.
If your handoff still depends on a Slack “looks fine” that never hits the ticket, an agent that “automates approvals” is accelerating a vibe.
Agents replace workflows, not jobs. More precisely: they replace the parts of a process nobody should still be doing by hand (chasing, re-keying, digging for status) once those parts sit on a coherent path. They do not replace the human who decides when the rule breaks, who gets access, or what to do when two systems disagree about reality.
A concrete scene: the morning after the exception board
Same mid-market ops world as the mapping work. One day later, different path.
The team mapped a fulfillment exception flow. Shortages, damaged goods, customer escalations that bounce between warehouse, CS, and a planner who keeps a Google Sheet of “real” inventory because the WMS quantity field lies after cycle counts.
On the board, three circles glowed:
- The Sheet that everyone trusts more than the WMS
- The CS → warehouse handoff that dies in email when the shift lead is offline
- The “just ship a substitute” exception that only the senior planner will approve out loud
Stabilization work is obvious: make the WMS match the Sheet or kill the Sheet; give the backup shift lead the same queue access; write the substitute rule so it isn’t tribal.
Instead, the pilot proposal arrives: an agent that watches the exception queue, drafts customer replies, and “routes” substitutes automatically.
Watch what happens if they ship that as-is.
The agent drafts beautiful customer emails while the inventory truth is still the Sheet. It routes a substitute against a WMS quantity that is wrong. It escalates into the same email handoff when the shift lead is offline, only faster, with more volume. Cycle time on noise drops. Cycle time on truth doesn’t.
That’s not an agent failure. That’s a bot on an unstabilized handoff.
The agent surface that would have worked looks smaller and less impressive in a demo:
- Watch the exception queue and flag items older than X hours
- Gather context: order ID, WMS qty, Sheet qty (while the Sheet still exists), last CS note, open tickets
- Draft a customer update for human send. Never auto-send on shortage until inventory truth is single
- Route to the named backup when the shift lead is offline, after access exists
- Flag “substitute requested” for the senior planner. Do not approve substitutes while the rule is still tribal
Routing, drafting, gathering context, watching queues, flagging exceptions. Humans keep the call on access, substitutes, and anything whose truth still lives in the Sheet. Boring, owned, measurable. That’s the point.
What to automate vs. what to leave human
Use the map as a sorting lens, not as a shopping list for bots.
Automate (when the path is clean enough):
- Routing. Send the work to the right queue or person based on named rules
- Drafting. First-pass replies, status notes, ticket summaries for a human to accept or edit
- Gathering context. Pull the fields and history a human would otherwise hunt across three tabs
- Watching queues. Age, SLA breach risk, stuck states, silent tickets
- Flagging exceptions. Surface the odd case with evidence. Don’t decide it away
Leave human (until the system stops lying):
- Exception calls. Anything where “it depends” is still tribal, not written
- Access. Granting, revoking, backup coverage. An agent cannot paper over missing permissions
- Shadow-truth decisions. When spreadsheet and system of record disagree, a human owns reconciliation
- Irreversible external commitments. Shipping a substitute, charging a card, changing a contract term, until rules and audit path are explicit
- Anything you would not put in writing for an auditor. If you wouldn’t document the rule, don’t encode it in a bot
The pattern is simple. Delegate motion and memory. Keep the judgment call where truth is contested.
Concession where it’s earned: some teams have already stabilized. Single system of record, written exception rules, backups with access. For them, the agent surface can grow as slices, with humans still on contested calls. The mistake is assuming that maturity because you finished a whiteboard session. The map revealed the debt. It did not pay it.
The agent surface test (run this on your map)
Print the photo of the board. Walk each arrow and each circle with five questions. If you can’t answer cleanly, that step is not agent-ready.
1. Where does truth live for this step?
Name one system. If the honest answer is “the Sheet” or “Sam’s inbox,” you stabilize first. An agent pointed elsewhere will lie with confidence.
2. Is the rule writable in one paragraph a backup hire could follow?
If only the senior person can teach it with stories, you don’t have a rule. You have tribal knowledge. Agents encode tribal knowledge as confident errors.
3. What happens when this step fails at 2 a.m. or on PTO?
If the path dies, fix access and backup before you add speed. Agents amplify whatever path you give them, including dead ends.
4. What would “done” mean if a machine did the motion?
Draft ready for human send? Ticket updated in the system of record? Flag raised with evidence? If “done” is still a vibe in chat, the surface isn’t defined.
5. What must stay a human call even when the motion is automated?
Write it beside the arrow: exception approval, access, reconciliation when systems disagree. If you can’t name the human-kept call, you’re about to pretend the agent owns risk it shouldn’t.
Score the workflow honestly:
- Green slice. Truth is single, rule is writable, backup path exists, done-state is explicit, human call is named. Candidate for an agent surface.
- Yellow slice. Almost, but one of the five is soft. Stabilize that one thing this sprint. Don’t pilot yet.
- Red slice. Shadow truth, tribal exception, or dead handoff. Process and access work. Not a model problem.
Most teams discover their first green slice is embarrassingly small. Good. Small and honest beats wide and fictional. Ship the green slice. Measure queue age, rework, and human time on chase-work. Then widen.
Implications for how you design the surface
Design like an operator, not like a demo.
Start from instances, not from capabilities. “Our platform can draft email” is not a surface. “On shortage exceptions older than four hours, draft a CS reply from these fields and park it for send” is a surface.
Bound the write path. Prefer agents that propose over agents that commit, until audit, rollback, and ownership are dull. Draft, flag, route. Auto-post and auto-ship come later, if ever, for that workflow.
Log the human-kept calls. If exceptions still go to a person, write down why. That log becomes the next round of rule-writing, or proof the rule should stay human.
Don’t confuse chat UI with an agent surface. A chatbot bolted onto fog is still fog with a prompt box. The surface is defined by the workflow slice and the system of record, not by whether someone can type a question.
Kill or promote the shadow tracker on purpose. While it still carries the real truth, treat it as the temporary system of record, or replace it before the agent writes anywhere else. Half-measures produce two truths and a bot that picks one at random.
Measure how fast breakage spreads, not just throughput. If tickets move faster but reconciliation debt grows, you automated the wrong slice. Throughput without truth is just accelerated cleanup for someone downstream.
I’ve watched teams celebrate “agent handled 40% of queue volume” while the planner’s Sheet grew three new columns to catch the agent’s mistakes. That isn’t progress. It’s a new upstream mess with a dashboard. The quieter failure: the agent nails the happy path, demos look great, and exceptions still wake the same three people. You decorated the part that was already fine.
How this sits with the series (and what it is not)
Playbook #1: most AI strategies fail because they start with technology.
Playbook #2: map before you model.
Playbook #3 (this one): after the map, choose a thin agent surface; don’t give a broken handoff a bot.
You can read this alone. If you skipped the earlier pieces, the rule still holds: workflow first, stabilize second, agent third. And third means a slice, not a takeover.
This is not a claim that people are obsolete. Stabilizing handoffs and naming human-kept calls is how you stop burning skilled operators on chase-work. Agents take the motion. People keep the call when truth is contested.
The question worth sitting with
You already know how the demo ends when you skip this step. Nice drafts. Faster nudges. Same fog. A pilot that looks alive in the slide and dead in the backlog.
So try the thinner move: take one mapped workflow, run the five-question test on every arrow, and mark green, yellow, or red. Automate only green. Leave humans the calls that still sit on shadow truth, missing access, or unwritten exceptions.
In the next post in this series, I’ll stay on this arc: what happens when agents start replacing the process nobody owns, not the people who were stuck holding it together.
For now, one operator filter:
If the handoff is still broken, an agent won’t heal it. It will only get you to the breakage faster.
Where on your board is the first green slice, and what human-kept call sits beside it so the agent doesn’t have to pretend?