AI is removing the coordination tax. The next bottleneck is authority

AI can make work move between teams faster than the organization can decide what the moving work is allowed to do. When that happens, the bottleneck shifts from coordination to authority.

For decades, large organizations have paid for coordination in ways that rarely appeared as a single line item.

A forecast waits for reconciliation. Procurement waits for finance. Operations waits for planning. A customer exception waits for someone senior enough to approve it. People translate context between systems, verify that the next team can act, schedule meetings, reconcile conflicting constraints and route decisions to the right owner.

McKinsey recently gave this a useful name: the coordination interface tax. In its 2026 research, handoffs, verification, reconciliation, waiting and routing can consume a very large share of work time in complex organizations. Its central argument is that agentic AI can reduce much of that friction by connecting workflow steps and handling routine verification and routing at machine speed.

I think that is directionally right.

But if coordination gets cheap faster than authority gets redesigned, the organization does not become fast.

It discovers a new queue.

When AI makes coordination faster, permission to decide becomes the slow part.

Coordination latency and authority latency are different things

A workflow can be slow for at least two very different reasons.

The first is coordination latency: the time spent moving information, reconciling inputs, finding the right person, checking whether a handoff is complete and routing work onward.

The second is authority latency: the time between having enough information to act and actually being allowed to act.

Those delays often sit next to each other, so organizations treat them as one problem.

They are not.

An agent can remove three days of manual reconciliation and still leave the work waiting twelve hours for an approval chain that was designed when reconciliation itself took three days.

The process is now technically fast and institutionally slow.

That is the transition I expect many companies to hit next.

Microsoft's current agent operating-model guidance points directly at the issue. Centralized governance creates consistency, but as demand grows the center can become a bottleneck. Its recommended mature pattern is to keep standards and guardrails central while pushing routine decisions outward, with explicit decision rights and governance by exception.

That is not merely a governance preference.

It is a latency architecture.

AI exposes approvals that used to hide inside the workflow

Slow approval systems are easier to tolerate when everything else is slow too.

If a planning cycle takes two weeks, a one-day approval feels normal.

If an agent compresses the planning cycle to two hours, the same approval becomes half the elapsed time.

This is why AI does more than automate work.

It changes the relative cost of organizational choices.

McKinsey's September coordination-tax analysis makes that shift visible. In the industrial example it describes, interface latency exceeded actual processing time by a wide margin. The article's proposed future state moves routine verification and reconciliation into agentic workflows, leaving people with a smaller set of genuinely consequential decisions.

That sounds efficient.

It also means those remaining decisions matter more.

The human is no longer approving every routine step. The human is increasingly the exception boundary.

If the organization has not redesigned who can decide, under what conditions, with what evidence and at what threshold, the exception boundary becomes the new queue.

The operating model problem is not "human in the loop"

The default enterprise answer to uncertainty is often to add approval.

That is understandable.

It is also incomplete.

A human approval step does not tell us:

• which decisions the human actually owns;
• what evidence should trigger review;
• which actions can proceed automatically;
• which thresholds require escalation;
• how long the approval is valid;
• what happens when the approver is unavailable;
• whether the decision is reversible;
• whether the same decision will be made differently by another team.

This is why "human in the loop" is too weak as an operating-model concept.

The more useful question is:

Where does authority sit, and what moves it?

OpenAI's Auto-review work on coding agents illustrates the principle at a technical boundary. Replacing frequent synchronous human approval with a separate review mechanism reduced interruptions dramatically while preserving review at boundary-crossing actions. That does not prove every enterprise approval can be automated. It shows something more useful: the architecture of approval can change without simply choosing between "human approves everything" and "agent has full access."

Organizations need the same design move at the operating level.

Authority should be designed before the exception arrives

Traditional organizations often discover decision rights by escalation.

A problem appears.

The first person cannot decide.

It moves upward.

Someone else wants legal input.

Finance joins.

A senior leader eventually makes the call.

The path becomes visible only because the exception forced the organization to reveal it.

That is expensive enough when exceptions arrive at human speed.

Agents can generate, detect and route exceptions much faster.

If decision rights remain implicit, the organization can end up automating the production of things that need permission while leaving the permission system untouched.

The result is not autonomy.

It is an automated waiting room.

Microsoft's 2026 guidance is unusually explicit here: ambiguity over who decides is where agent centers of excellence slow down. Its recommendation is to push decisions to the lowest level that can make them safely, while the center owns only the few gates necessary to keep the estate governed.

That is the principle I would generalize beyond a CoE.

Do not centralize every decision. Centralize the rules for which decisions may be decentralized.

I would measure authority latency

Most AI programs already watch technical latency.

How long did the model take?

How long did the tool call take?

How long did retrieval take?

Those numbers matter.

But as agentic workflows mature, I would add a business-operating metric:

authority latency: the elapsed time between a workflow becoming decision-ready and the authorized action being taken.

That number is often invisible because companies measure process duration, not the time spent specifically waiting for permission.

It should be visible.

A useful breakdown might be:

The goal is not zero authority latency.

Some decisions should be slow.

The goal is to make the delay intentional.

The authority architecture needs four layers

I would separate four things that organizations often mix together.

1. Standing responsibility

Who is accountable for the outcome?

This is the role-level question.

A domain leader may own customer refunds, production deployment, credit policy or procurement risk.

Accountability can stay stable even when execution changes.

2. Delegated decision rights

Which decisions may be made without asking that owner every time?

This is where thresholds matter.

Refunds below a certain amount. Deployment to a reversible environment. Purchase orders inside an approved vendor and budget envelope. Customer exceptions that match known patterns.

Delegation turns authority from a person-dependent event into an operating rule.

3. Runtime authority

What may this agent do for this task now?

This is the narrower layer I wrote about in An AI agent should get authority per task, not permissions per role.

The role sets the ceiling.

The task sets the active authority.

4. Escalation authority

Who can expand or override that boundary when the current envelope is not enough?

This matters because exceptions do not disappear.

The system needs a known route for them.

If escalation means "find someone senior," the organization has not really designed the decision.

It has designed a search problem.

Faster coordination can make bad authority design more visible

Deloitte's October 5 analysis of frontier agents makes a related point from the risk side.

As agents gain access to data and authority to act, the organization needs to know whether it can observe, constrain and stop those actions—and whether the actions remain aligned with business intent. The incidents Deloitte references come from testing environments and should not be treated as evidence that ordinary enterprise agents routinely behave that way. The important implication is organizational: faster autonomous action increases the value of clearly designed control boundaries.

That means the problem is not "AI moves too fast."

The problem is AI can move faster than the organization's implicit rules can be interpreted.

A rule that depended on someone asking a manager in a meeting is not a machine-speed rule.

A policy that says "use judgment" is not a delegated decision right.

A governance process that depends on a weekly committee is not compatible with a workflow that now completes in minutes.

AI forces vague authority to become explicit.

That is uncomfortable.

It is also useful.

The next redesign target is the approval graph

Process maps show steps.

Org charts show people.

Neither shows authority well.

For an agentic workflow, I would map an approval graph.

For each consequential decision:

• what event makes the decision ready;
• who is currently allowed to decide;
• what threshold permits automatic execution;
• what evidence is required;
• which exception changes the route;
• who can widen the boundary;
• how long the approval remains valid;
• whether the action can be reversed;
• what gets logged.

Then measure where time accumulates.

Some approvals will survive.

Some should disappear.

Some should become automated policy checks.

Some should become delegated thresholds.

Some should remain human because the consequence deserves judgment.

The point is not to remove humans.

The point is to stop using human availability as the default architecture for authority.

This is where AI transformation becomes organizational

A company can automate coordination without changing who is allowed to decide.

That will produce faster handoffs.

It will not necessarily produce a faster company.

This is why Stop Adopting AI argued that transformation is not the accumulation of tools. The operating model has to change with the technology.

And this is where the argument becomes more specific.

When coordination was expensive, organizations built structures to manage coordination.

As coordination becomes cheaper, the remaining value of those structures has to be re-examined.

Some management layers exist partly because information had to be gathered, translated and passed upward before a decision could be made.

If agents can do much of that gathering and translation continuously, the organization's next constraint may be that authority still travels upward by habit.

McKinsey's October operating-model work makes this point directly: flatter, more agentic organizations only work if reduced coordination is replaced by clearer decision rights and stronger judgment.

That is the trade.

Less coordination does not mean no structure.

It means structure has to move from routing information to designing authority.

The practical test

When an AI workflow becomes faster, ask five questions:

1. Which decisions are now ready sooner than before?
2. Which of those decisions still wait for a person?
3. Is the wait caused by genuine judgment, or by an inherited approval rule?
4. Can the decision be delegated with thresholds, evidence and reversibility?
5. If not, is the escalation path explicit enough to operate at the new workflow speed?

If you cannot answer those questions, the workflow may be automated while the organization remains unchanged.

That is the next bottleneck.

AI is reducing the cost of coordination.

The organizations that benefit most will not be the ones that simply move work faster between the same decision gates.

They will be the ones that redesign the gates.

Sources