Everyone can tell you agents are coming. Almost no one can tell you what happens first, what happens next, and what has to be true before you move. This is the route — the platform, the organization, and the people moving together, because none of them can arrive alone.
You do not rewrite your system. You connect it — carefully, under governance — to agents that work alongside an organization redesigned to let them. The core stays. What changes is who decides what, and how that gets enforced. The sequence below is how that happens, and why it cannot be done out of order.
The common objection to doing technology and organization together is that it doubles the project. It doesn't — because they aren't two projects running side by side. They are one sequence with dependencies.
You cannot make the core legible to an agent until you know which workflows matter. You cannot grant an agent authority until a human owns its decisions. You cannot strip organizational drag until you can see, task by task, what an agent could actually take. Each phase produces the thing the next phase needs.
That is also why the human work survives a budget review. It isn't change management running alongside. It is a gate: no named owner, no agent in production.
Stand at the end state and draw the map backward. Planning forward from today lets your current org chart, approval chains and job families act as gravity on every decision you make. Backcasting replaces "how does this fit what we do?" with "what would we build now, and what connects here to there?"
Leadership agrees what governance means before anything is granted authority — not after the first incident.
Name the decisions the business actually makes, and who owns each one today. Most organizations have never written this down.
Nothing is built yet. The output is an architecture on paper — where agents will live, where the core stays, where the boundary sits.
A destination signed by the person who can fund it. Skipping this is the most reliable way to fail — every stalled initiative where the technology worked traces back to a destination nobody agreed on.
You cannot close a distance you haven't measured. This phase reads all three lanes and produces one thing a plan can be built on: how far your knowing sits from what an agent can act on — and how much of the gap is platform, structure, or people.
Where judgment actually lives, who holds it, and how much of it has never been written down anywhere.
Coordination load, decision latency, and which approvals are regulation versus which are habit. They look identical from inside.
Reachability, security surface, agentic load. What can be called, by whom, under what authority, with what left in the journal.
You know your distance — and you know whether you can transform in place or need to build beside. That question is settled here, not assumed at the start.
The usual advice draws this line at fifty employees. That number is a proxy, and a weak one. We have seen thirty-person shops that needed a twin and three-hundred-person shops that transformed in place.
What actually decides it is whether you can change a workflow where it stands without triggering something that stops you.
The workflow changes where it runs. Faster, cheaper, and available when coordination is light and sponsorship is real.
A twin runs the workflow in parallel until it's proven, then the old path is retired. Slower, safer, and necessary when the organization would reject a change in place.
Either way, the first move is the same: one workflow, end to end, proven. The branch changes the migration mechanism. It does not change the sequence.
This is where the IBM i platform breaks the usual playbook — in your favour. Most organizations reach this phase and find their institutional knowledge scattered across documents, threads and inboxes, rotting. Yours is in production, executing correctly, every day. It isn't rotted. It's unread.
So the work is not archaeology and it is not a rewrite. It is connection: making forty years of encoded logic reachable and explicit, so an agent can act on it without anyone touching what it does.
Capture the reasoning from the people who hold it. This is the work with a date on it, and the date is set by retirements, not by you.
Name the decision each workflow encodes — and who owns it. The code says what happens. Someone still has to say why.
Connect to RPG and Db2 rather than translating away from them. Source becomes readable, procedures callable, the data reachable through one governed door.
The logic an agent will act on is explicit, owned, and legible to someone who wasn't there when it was written — whether that someone is an agent or the person who replaces your longest-tenured developer.
Agents amplify whatever system they enter, including bureaucracy. Give agents to a slow approval chain and you get a faster slow approval chain. So before adding anything, you take the organization apart at the task level and look at it honestly.
The roles change here, not at the end. People move from executing the work to governing it — and that climb has to be built, not assumed.
Which decisions need more than three people. Where information waits. Which approvals exist for risk, and which exist for comfort.
Every task scored for agent readiness. Some are ready today. Some need a pilot. Some stay human permanently — and knowing which is the point.
You can say, task by task, what an agent takes and what a person keeps. Nobody is guessing, and nobody is being told their job disappears without being shown what replaces it.
One workflow. Agents run against the real thing while people keep doing it, and every place the two disagree is recorded. Nothing is deprecated until the numbers say so — and the numbers are defined before the run starts, not after.
Named owners, a review queue, and every override captured with its reason. Overrides are the most valuable data the pilot produces.
The boundary between what an agent proposes and what the organization permits is enforced, not described in a policy document.
Agents reach in from outside and never live inside. The platform holds the line through object authority — the same enforcement it has always had.
The override rate is falling. If people correct the agent as often in month three as in month one, you don't have a system that learns — you have automation with a chat window, and the honest move is to stop.
One proven workflow is a pilot. The point is what it earns you: a pattern the next workflow follows faster, and a structure that no longer has to route every decision through a person to be safe.
The climb completes. People who once ran the process now direct agents, hold the exceptions, and decide what the work should be.
Structure follows the boundary you proved, rather than the boundary you assumed. The org chart stops being a latency map.
The stack widens past the first workflow. The governed door stays a single door — that discipline is what makes the second one cheap.
The next workflow is faster than the last. If each one costs the same as the first, you built a project. If they compound, you built a capability.
Governance is not a stage you reach. It runs the entire length, from before the first agent acts until long after the last workflow migrates. It starts by watching and saying nothing, earns the right to escalate, and only then holds a switch. Every failure you have read about is a governance gap, not a technology one.
Phases 01 and 02 are diagnosis. They tell you where you stand, which branch you're on, and which workflow is worth proving first. Phase 03 is where the platform work begins — and it is connection work, not migration work.
You don't have to commit to six phases to start. You have to know which one you're in.
The diagnostic reads all three lanes and gives you a full score — no email required, printable, and yours whether or not we ever speak. It is Phase 02, and it is the phase that decides everything after it.
Run the HOT scan →