Enterprise Frictions and AI Productivity

In a previous post, we explored this topic through a simple but powerful idea: the difference between a speedometer and a paceometer (https://elandi.ai/blogs/ai-productivity-paradox).

A speedometer suggests a linear story: the faster you go, the shorter your journey. But a paceometer reveals a more realistic story---each additional increase in speed delivers progressively smaller time savings.

For example, on a 10-mile journey: - 20 mph → 30 minutes\

• 40 mph → 15 minutes\
• 60 mph → 10 minutes\
• 80 mph → 7.5 minutes\
• 100 mph → 6 minutes

The gains flatten quickly. Going from 80 to 100 mph saves just 1.5 minutes.

This already challenges the idea that "more model accuracy = more AI productivity." But there's a deeper, more important dynamic at play.

The Missing Variable: Friction

Real-world systems are not smooth. They are full of interruptions: approvals, compliance checks, context switching, fragmented data systems, and manual handoffs.

These interruptions force deceleration.

So the real question becomes: what happens when speed meets friction?

Simulation Setup

To explore this, we simulated a simple journey:

• Distance: 10 km
• Acceleration: 1 m/s²
• Max speeds: 40, 60, 80, 100 km/h
• Number of interruptions: 1, 2, 4, 8, 16, 32

Assumptions

1. Interruption points are randomly distributed along the journey.
2. At each interruption, the driver must decelerate to a full stop and then accelerate again.
3. If interruption points are close together, the driver may never reach maximum speed.
4. The final segment ends without requiring a full stop at the destination.

Physics Model

Each segment of the journey is computed using basic kinematics.

Case 1: Segment long enough to reach max speed

Time = (2 × v / a) + (d − v² / a) / v

Case 2: Segment too short to reach max speed

v_peak = sqrt(d × a)
Time = 2 × v_peak / a

Final segment (no stop required)

Time = (v / a) + (d − v² / (2a)) / v

Simulation Code (Python)

import numpy as np

def segment_time_stop_to_stop(distance, vmax, a):
    d_needed = vmax**2 / a
    if distance >= d_needed:
        return 2*vmax/a + (distance - d_needed)/vmax
    v_peak = np.sqrt(distance * a)
    return 2 * v_peak / a

def simulate(distance, vmax, interruptions, a):
    points = np.sort(np.random.uniform(0, distance, interruptions))
    segments = np.diff(np.concatenate(([0], points, [distance])))

    total = 0
    for seg in segments[:-1]:
        total += segment_time_stop_to_stop(seg, vmax, a)

    total += segments[-1] / vmax
    return total

Results

The simulation results show that at low interruption levels, speed matters significantly.

• With 1 interruption, increasing speed from 40 to 100 km/h reduces journey time from ~15.3 to ~6.7 minutes.

However, as interruptions increase, the benefit of speed diminishes.

• With 32 interruptions, the same speed increase only reduces time from ~20.6 to ~17.0 minutes.

Even more striking: at high interruption levels, most speed levels lead to similar results.

Why This Happens

As interruptions increase, the system spends more time decelerating and accelerating, and less time cruising.

Eventually, total time is dominated by these stop--start transitions rather than sustained high-speed travel.

In such systems, increasing maximum speed has limited impact.

Back to AI

This dynamic closely mirrors what we observe with AI in organisations.

We are making rapid progress in:

• model capability
• latency
• reasoning
• benchmarks

Yet productivity gains remain modest in many domains.

Why?

Because organisations resemble high-interruption systems:

• approval chains
• compliance bottlenecks
• fragmented tooling
• manual validation steps
• cross-team dependencies

These introduce constant deceleration.

The Core Insight

Productivity is not simply a function of speed.

It is a function of speed × friction.

If friction remains high, improvements in speed produce diminishing returns.

Implications

The limiting factor in AI adoption is not model performance---it is organisational design.

The biggest gains will not come from faster models, but from:

• reducing interruptions:
• streamlining workflows
• integrating systems
• eliminating unnecessary handoffs

Final Thought

We are building extraordinarily fast engines.

But many organisations are still operating on bumpy roads.

Repave the road first. Then speed will matter.