Beyond bots: the rise of agentic operations.

The bot era and its ceiling

If you ran a transformation program in the last decade, you have war stories about brittle robots. A bot that ran beautifully for six months, then a screen layout shifted by twelve pixels and three quarters of the back office reverted to manual. A "center of excellence" that quietly turned into a maintenance shop. Pilots that demonstrated 80% savings on a slide deck and 8% in the audit.

The pattern wasn't a failure of effort. It was a failure of fit. Classic RPA was extraordinary at one thing: replaying deterministic, low-variance work. The moment the upstream world introduced ambiguity — a new vendor invoice format, a customer note that didn't match the template, a regulatory letter requiring judgment — the bot stopped, and a human filled in.

The economics of that model peak quickly. The first 30–40% of any process is genuinely automatable with scripts. The next 30% requires reading, classifying, and reconciling things that don't look identical. That middle band is where most enterprises got stuck — and it's where agents now live.

What changed

Three things, in sequence:

1. Models that can read unstructured input. A frontier model can extract fields from a malformed PDF, summarise a 40-page contract, and re-write a clinical note in structured form — at human accuracy for the long tail of edge cases that broke OCR pipelines.
2. Tools. Models can now call functions. That sounds small. It is not. It moves the model from "a thing that writes text" to "a thing that takes actions, observes results, and tries again."
3. Loops. Wrap a model with a planner, a memory, and a critic, and you get an agent: a system that decomposes a goal, executes steps, checks its own work, and asks for help when uncertain.

The combination is qualitatively different from a bot. A bot follows a recipe. An agent has a goal and a budget — of steps, tokens, latency, or risk — and it figures out the recipe.

From scripts to judgment

The mental model we use with clients is a simple two-by-two. On one axis: how structured the work is. On the other: how much judgment it requires.

• Structured + low-judgment — invoice posting, password resets, status updates. This is bot territory. Keep what works.
• Structured + high-judgment — credit decisions, claims triage. Agents with strong tool use and policy guardrails.
• Unstructured + low-judgment — reading mail, classifying tickets, extracting data. The model layer alone, called from existing workflows.
• Unstructured + high-judgment — case investigation, complex servicing, advisory work. Agent + human-in-the-loop. The agent prepares; the human approves.

The interesting shift is that the bottom-right quadrant — the work nobody automated for twenty years because it required reading and thinking — is now in play. Not for full autonomy, but for preparation. An agent that pre-reads every case, drafts the recommendation, surfaces the three things the analyst should double-check, and waits for sign-off is a different category of productivity than a bot that pastes data between two screens.

The new operating model

The companies getting this right are not the ones with the most models in production. They're the ones who rebuilt three things deliberately:

1. Process control points. Where does a human have to approve? Where is the policy enforced? Agents are powerful and also fallible — the operating model needs explicit gates, not implicit ones.
2. Observability. You need to see what the agent saw, what it considered, what it chose, and why. The org chart of the future has dashboards for non-human workers next to the ones for people. If you can't audit a step, you can't trust it.
3. Skills. The new front-office role is "agent supervisor": someone who reviews exceptions, tunes prompts, calibrates thresholds, and reports on where the bots are failing and why. This role doesn't exist on most org charts. It needs to.

Where to start

Three concrete moves, in order.

1. Pick a process where the current bottleneck is reading, not deciding. Document understanding, case intake, complaints classification, KYC document review. The wins are large, the risk is low, and the path to production is short.

2. Build the supervision layer before you scale. If you can answer "what did the agent do today, how many exceptions did it raise, and what was the override rate" — you can scale. If you can't, every new agent multiplies your blind spots.

3. Treat the agent as a member of the team. It has a job description (the prompt), KPIs (accuracy, throughput, exception rate), a manager (the supervisor role), and a probation period (the first 60 days in production, where it works in shadow before going live).

The bottom line

The bot era taught the industry that automation is a sociotechnical change, not a software install. The lesson is the same in the agent era — only the surface area is larger and the consequences of getting it wrong are louder. The firms that win are not the ones who deploy the most agents. They're the ones who build the operating model that makes agents safe to deploy.

If "intelligent automation" still feels like a slide deck in your firm, the next 18 months are going to be uncomfortable. The good news: the path is well-trodden, the technology is ready, and the people problem — the supervision layer, the org design, the trust scaffolding — is the thing we know how to help with.