When capability arrives first, the old dispatch system breaks

In the 1830s, US rail mileage grew roughly 120-fold. Transport capacity exploded — and on October 5, 1841, two trains on the Western Railroad in Massachusetts collided due to a coordination failure, killing passengers. The steam engine was already fast enough; a single conductor just couldn't manage an ever-growing network alone.

Railroads later added division managers, written job responsibilities, and reporting lines. A large chunk of modern corporate management structure grew specifically to coordinate capability that had already outrun the old system. Railroads went on to become one of the largest industries of their era, at their peak accounting for roughly 60% of US stock market value.

Sivulka argues this round with agents follows the same structure: models and tools are the new tracks, but companies are still dispatching them like a single rail segment. Worse, every employee — including the ones least equipped to spell out a task — has been handed near-unlimited digital headcount and budget.

People and agents break down from the same organizational disease

The original summary table. Below, we dig into the links that hold the chain together. Source: chart from the original piece

Burning tokens doesn't fix "not knowing how to use them"

The "burn more tokens and win" hype cycle, per the original piece, lived and died within a month. The real problem is usage: Sivulka estimates maybe 1% of employees actually give an AI proper context — can spell out a process clearly and tolerate a context window that gets messy along the way. The other 99% get handed agent scaffolding and mostly produce "loops."

Claude Code, Copilot, Karpathy's Autoresearch, and the loops inside every harness are often written up as band-aids: when a person hasn't clearly defined the task, the system has no choice but to brute-force its way forward with retries. An agent endlessly calling itself to fix itself looks like strong autonomy, but more often it's a symptom of missing clean goals, boundaries, and stopping conditions upstream. You end up spending tokens to buy more token-spending.

Loops blow costs wide open.The higher multiplier in the chart is labeled illustrative; the caption cites a reported range of roughly 1–17x per completed task. The mechanism holds regardless: the vaguer the task, the more expensive the retries. Source: chart from the original piece

Idle spinning reproduces itself

The author is blunt about the state of management at most companies: most people don't actually move the business forward — they just rubber-stamp at each layer, then hire more people to feed a machine that exists to keep existing. That's looping too. Sometimes cutting loops beats adding more of them. He cites Elon cutting roughly 80% of headcount at X and the company still running, plus the common wisdom that private-equity operating partners make a living by cutting the redundant. Applied to AI:

Two pyramids.Left: the thin slice of a company that actually delivers. Right: the thin slice of tokens in an agent session that's actually useful. The big middle chunk is management / loops on both sides. The caption states this is for illustrative purposes only. Source: chart from the original piece

What's really valuable is 100x context — and people aren't necessarily willing to hand it over

Traditional software promised: write it once, run it cheaply forever, barely need to watch it. AI trades that for "can do almost anything," at the cost of "hard to reliably do just one thing right." Once tokens get treated as employees, a lot of the usual promises start to crack:

• More accurate — but only when the prompt is right
• Faster — but retrying 100 times makes "speed" meaningless
• No office politics — but it will build empires of token spend
• Never quits — but "dies" between model versions and new sessions
• Trustworthy — yet often confidently wrong in perfect formatting

Where AI genuinely and reliably beats humans is scaling speed: hiring, onboarding, and attrition are all expensive; scaling tokens is nearly instant. That's exactly why mismanaging it is so costly, and why finding and amplifying that 100x context matters so much. On average, people may be cheaper than tokens; at scale, good tokens are cheaper. Management is the exchange rate between the two.

Management widens the price spread.Measured as "dollar cost per hour of accepted work delivered": good management can push this very low, bad management can push it into the thousands of dollars. 2027–2028 figures are trend extrapolations. Same AI, but management decides whether it's cheap or expensive. Source: chart from the original piece

There's a political problem inside companies that's only going to grow: employees don't want to teach their proprietary know-how to AI. They're starting to realize these systems aren't just "helping me be more productive." The piece points to Meta: even equity-holding employees pushed back hard when the company used employee context as training data. Tribal knowledge has been a livelihood for centuries; AI is the first technology that asks workers to hand it all over at once. The people holding 100x context have the least incentive to give it up.

What scales: acceptance criteria, and codifying the company into a system

Why code works first: it has built-in pass/fail

The best way to manage a token workforce is the same as managing people: define what "done well" looks like first. Right now, coding is nearly the only AI use case that's broken out of political gridlock while also growing the pie. The mechanism is hard-edged: code either runs or it doesn't, tests are green or red. The author even attributes "coding accounts for the bulk of today's AI revenue" to exactly this.

Swap "organize the client folder" for "write a script that exports a CSV" (illustrative): the deliverable is clear (a file), the stopping condition is clear (script runs without errors), the acceptance criteria are clear (open the CSV, check the columns). Even if the agent loops along the way, it has an objective finish line. Work without that finish line can only be watched over by a human, and scaling grinds to a halt immediately.

So the original piece argues: to scale any given domain, someone first has to build the business-specific evals for it. A concrete acceptance criteria set matters more than teaching everyone prompt engineering, and more than shipping a chat box. Management, in essence, is turning vague human procedures into repeatable, checkable standards. A company's eval suite becomes one of its most valuable assets. Generic evals or a generic agent don't create differentiation — a company's own judgment standards are the actual moat.

The easier a job is for machines to grade, the harder AI eats into it.Because pass/fail is unambiguous, software engineering captures the largest illustrative share of AI revenue; strategy, aesthetic judgment, and deal-making stay closer to the "pure human taste" end. The caption notes revenue shares are directional, not measured. Source: chart from the original piece

Buying models isn't enough — the company also has to be "codified" into the agent

Enterprises have spent several years now on foundation model commitments, application-layer tools, and internal builds. Sivulka argues all that spend quietly papers over an uncomfortable fact: nobody has yet made AI reliably production-grade. The money went to "a model that works," not to "figuring out what counts as doing this specific business correctly."

One bet Silicon Valley is making on this is that today's companies simply can't solve it — hence funding for Neofirms, AI-native service companies built to go after the roughly $21 trillion in knowledge-economy service spend: build an AI-native service workforce from scratch, with no legacy baggage, and go straight after the business of traditional law firms, consultancies, and outsourcers.

Sivulka bets on the latter, writing that "AI transformation firms will end up an order of magnitude bigger than any Neofirm." His reasoning is concrete: legacy companies already hold differentiated, profitable processes, plus existing customers and distribution channels. What they lack is the ability to codify all that into systems an agent can execute and that can be checked for correctness. Neofirms can apply outside pressure, but the biggest asset still sits inside the incumbent.

It sounds like a one-off project, but Jevons paradox applies: every use case that ships tends to spawn ten more. As capability gets cheaper, usage grows, and total transformation effort actually goes up. So "transformation" turns into long-term operations, not a turnkey handoff. AI-era transformation also goes beyond ontology modeling, custom software, and the occasional well-crafted prompt. The hard work is in the evals, in minimizing tokens, in understanding a business well enough to program it.

The prototype is Palantir.By the logic of "Claude can replace custom software," it should be getting shorted — instead its stock has taken a different path entirely. The piece's reading: what it's actually selling is transformation capability. The stock chart illustrates market pricing and narrative, not proof that a trillion-dollar market is guaranteed. Source: chart from the original piece

Time to manage

Every phase of the AI boom has had its own catchphrase: sell picks and shovels → build the infrastructure; Service-as-a-Software → spawn a wave of Neofirms. The original piece closes bluntly: infrastructure is here, services are here, the job now is making the trains run on time. What's left to do is get into the field — find the 100x context, write down which loops actually work, and redirect the intelligence that's currently being badly wasted.

The central analogy is 19th-century railroads: the tracks (capability) arrived first, dispatching (management) came later. Agents are the new tracks; companies are still dispatching them like a single rail segment, while handing every person unlimited digital headcount.

The seven parallels boil down to three things: task definition, execution visibility, and knowledge plus incentives. A stronger model doesn't automatically fill in these three layers.

Say Xiaohu drops a vague task into an agent pool: without four specific things, the loop never breaks.

What scales isn't "spin up more agents." It's repeatable acceptance criteria (evals) plus codifying the company's real rules into the system. Coding works first because pass/fail can be judged automatically.