Everyone is wiring agents into everything right now: drafting emails, triaging tickets, writing the first draft of the report, chasing data across six systems. And it works. Everyone says so, loudly. The demo lands, the team cheers, the founder tweets.

What nobody tweets is that the win is smaller than it looks and stops growing almost right away.

Not that the agent is bad; it is genuinely great. Drop it on a task, and that task gets faster, cheaper, and basically infinite, and yes, that part really does scale. But a task is not a system.

You sped up one step in a chain of fifteen, and the other fourteen didn't budge: the approvals, the handoffs, the "let me loop in Karen." All the moments where a human has to decide something. So the report gets drafted in four seconds and then sits in a queue for four days, exactly like before. The step got faster. The system hit a wall. You just made the wall arrive sooner.

Let me tell you why with a factory story.

The factory that changed nothing

Around 1900, factories started ripping out their steam engines and dropping in electric motors. Electricity! The future! Clean, quiet, modern. And then productivity did not move for decades. Economists still write papers trying to explain the gap.

The reason is mechanical. A steam factory had exactly one engine, a single giant machine in the basement. It didn't power the machines directly; it spun one long steel shaft that ran the length of the ceiling, and every lathe and loom hung off that shaft by a leather belt. Shaft turns, belt turns, machine works. One source of power, dragged down the middle of the building. It dictated everything: where each machine sat, who stood next to whom, which department lived upstairs. All of it came down to one constraint: you had to be close enough to the shaft to reach it with a belt. The shaft was the law of the building.

When electricity arrived, nobody woke up and redesigned the plant. Why would they? They had a working factory and a better engine. So they did the sensible thing and swapped the engine, leaving everything else alone. Out went the steam engine in the basement; in went one big electric motor, bolted to the same spot, spinning the same shaft, the same belts dropping to the same machines in the same places. They changed the power source, not the factory. Drop-in upgrade, same layout, cleaner energy. Any reasonable person would have done exactly that.

And it worked a little. Enough to feel like progress, not enough to move the needle. Old management advice addresses this trap: the cardinal sin is to pave the cow path instead of getting rid of it. Electricity just handed everyone a fresh way to commit that sin. So they electrified the cow path, and a cow path, no matter how much voltage you run through it, is still a cow path.

The real leap took thirty years and a different question. Not "where does the new engine go," but the heretical one: if the engine can sit anywhere now, why is my factory still shaped like it can't? One motor per machine. Machines wherever the work wants them. The whole plant redrawn around the flow of the job instead of the location of the power. That wasn't an upgrade; it was a teardown, and it is the only thing that ever paid off.

If you have been near an AI strategy deck lately, you have probably heard some version of this already. The electric-motor story is having a moment, and the usual lesson drawn from it is "don't just digitize your old process." True, as far as it goes.

But almost everyone stops there, at the level of the workflow, as if the task were to find the one process worth redrawing. That is not the interesting part. The interesting part is what moved, and it is not the process; it is where the value lives. And right now, you are bolting a shiny new motor onto a steam-shaft workflow.

It’s not the workflow. It’s the org chart.

Here’s the thing, though: it isn’t just your workflow that’s shaped like a dead constraint. It’s the whole company.

Think about what an organization actually is. Roles, departments, hierarchy, the org chart itself: every line exists to economize on one resource, the scarce and expensive one nobody could fully coordinate. Human execution.

You batch because starting was expensive. You specialize because one person doing one thing all day got good at it. You chain handoffs because no single human could hold the whole job in their head. You stack approval gates because mistakes were costly. You hire managers to coordinate the doers and managers to coordinate the managers.

Notice all of it and see what it is: a fossil of one fact. Doing stuff used to cost a lot.

And Conway's law twists the knife. You can only build systems shaped like the org chart, so if the organization is a fossil, everything it ships is born fossilized too.

Now doing stuff costs almost nothing. You hand an agent the one painful step in a nine-step process, the step the other eight were built to set up, check, and clean up after. The agent nails it in two seconds. Then you wait three days for Karen in legal to approve it anyway.

Congratulations. You electrified the cow path.

Because an agent does not fix your process. It just runs it, at a speed and scale you could not previously reach. It is an amplifier. Point it at a process that actually works, and it gives you more of what works. Point it at a cow path, and you get the same crooked, pointless path, only faster, cheaper, and everywhere.

And here's why running it faster buys you so little. Speed up one step of a system by 100x, and the system's total speed is now decided entirely by the steps you didn't speed up. That is Amdahl's law, arithmetic wearing a lab coat, and it is the whole argument in one line.

You drove the cost of one step near zero, so throughput is now governed by everything you left untouched: judgment, approvals, handoffs. The process was optimized for a constraint that just stopped binding, making it suboptimal by construction. The work didn't get worse. The ground moved under it.

The bottleneck moved, and the org chart did not get the memo.

So what's left when the doing costs almost nothing

This should keep you up at night. In a good way.

Stripping execution from a job leaves judgment: experience, intuition, plain good sense. Agents are spectacular at the how and dead silent on the why; they will never ask what if we did not do this at all. Those were the actual work: deciding what matters, what the thing is even for, what to do when the situation is genuinely new instead of merely hard. None of that moved. The agent took the easy part, leaving you holding the part that was always yours.

Agents do not have it. They execute beautifully and confidently, right off the cliff, all the way up to the one weird edge case where somebody needed to think.

So execution gets cheap enough to detach, and the scarce input is no longer doing but the judgment that directs it. That's the whole reason the bottleneck moved: you don't reorganize around what's cheap; you reorganize around whatever is now holding you back.

Three economists made the same case from a different direction in Prediction Machines, framing all of AI as a collapse in the cost of prediction, with value migrating to the judgment about what to do with the prediction. Same conclusion, arrived at from the price of compute instead of the shape of a factory.

We spent two centuries learning to divide labor. The harder question now is how to divide judgment, and it will not divide like tasks did. The moment you write judgment down as a fixed rule, it stops being judgment, so you cannot lay it out along a line. What you can do is give it places: bounded spots where what is known gets checked, certified, and deepened instead of reinvented every time someone asks.

That is what I spend my days building. Right now your hard-won judgment lives in the worst places imaginable: a Slack thread nobody can find, the head of the guy who quit last spring, a model's fresh guess in a slightly different mood every time you ask. None of those is something you can hand an agent and trust. So you give judgment a real place instead. A human decides once, it gets certified, it carries an honest label of how sure we actually are ("the agent can act on this part, a human still owns that one"), and then it is reused a thousand times instead of reinvented. The agent runs on the certified part and hands the uncertain part back to a person; a home for judgment a machine can act on without anyone losing track of who is responsible.

That is the work that matters over the next few years: not dropping agents into the workflow, but noticing the workflow was a fossil, deciding where judgment should live, and building its place.

None of this is new, though. "Don't automate, obliterate," Michael Hammer wrote in 1990, alongside the line about cow paths. The advice was right, and almost nobody followed it because obliteration is terrifying, and a faster old process feels close enough to a new one.

What is new is that the stakes have flipped. For thirty years, paving the cow path just meant leaving value on the table. Now the cheap part is racing ahead and the judgment that steers it is still scattered across heads and threads, so the gap between how fast you execute and how well you decide is what breaks you. The question stops being how to make work faster. It becomes where judgment lives, and whether you have built it a place to live before you hand the keys to an agent.

A cow path at the speed of light is still a cow path.