The Middle Cannot Finish

That small humiliation has an architecture, and the architecture has a law. It was written down in four quiet pages by three systems engineers — Jerry Saltzer, David Reed, and David Clark, working at MIT’s Laboratory for Computer Science — presented in Paris in 1981 and published in 1984. It is arguably the most consequential design argument in the history of networks, because the internet is what it looks like when somebody believes it. And it says something that almost nobody building AI right now wants to hear: intelligence placed in the middle of a channel can never finish the job. Not because the middle is slow, or dumb, or underfunded. Because the test of whether the job was done correctly lives somewhere the middle can never stand.

01The file that had to arrive

Their worked example was deliberately boring: move a file from computer A to computer B without damage. You could make every link in the path careful — add checks to every hop, every router, every disk. The engineers of the day were doing exactly that, gold-plating the middle. Saltzer, Reed, and Clark pointed out the flaw: however careful each step becomes, the only check that settles the question — did the file arrive intact? — is the one the two ends run themselves, comparing what was sent against what landed. The middle can lose the file after its last checkpoint. The disk can corrupt it after the network was done being careful. Correctness is defined at the ends, so correctness can only be verified at the ends.

Hence the sentence in the box above. The function — careful transfer, and by extension any function whose success is judged by the endpoints — cannot be provided by the channel. And then comes the most quietly brutal parenthetical in computer science: an incomplete version of the function, provided by the middle, “may be useful as a performance enhancement.” That is the ceiling. The middle’s best case, written into the founding argument of the internet, is helper. Never finisher.

Figure 01 · Two places to put the smart

The same wire, two architectures

The Intelligent Network

Plain phoneno memory, no logic

→

Smart switchrouting · features · billing · “services”

Smart switchthe carrier decides what the channel can do

→

Plain phoneno memory, no logic

The telephone network: capability lives in the middle, and the ends take what they are given.

The End-to-End Network

Smart endpointmeaning · intent · verification

→

Plain middledeliver the bits

Plain middledeliver the bits

→

Smart endpointruns the check that counts

The internet: the middle carries, the ends understand. This is the one that won.

02The network that believed in its own middle

The telephone network was the Intelligent Network — that was the industry’s own proud term for it. All the capability lived in the switches; the device in your hand was deliberately simple. In 1997 a researcher at AT&T Labs Research named David Isenberg wrote an essay called Rise of the Stupid Network, arguing that his employer’s crown jewel was obsolete: the future belonged to dumb transport in the middle and intelligent, user-controlled endpoints. The essay was acclaimed nearly everywhere it traveled. The one place it was unwelcome was the company whose network it described. He left the following year, and the network he predicted ate the network he left. Your phone calls ride the stupid network now. So does everything else.

The lesson was never that dumb is a virtue. It is that the Intelligent Network was holding a position it could not hold: it promised to complete functions — what a call could do, what a service could mean — that were only ever checkable at the ends. The moment the ends could afford intelligence of their own, the middle’s claim collapsed.

03What AI changes — and what it cannot

For four decades the end-to-end argument governed bits, because only machines sat at the ends of machine channels. Human channels were different. The ends of those — customers, patients, citizens, you — could not afford dedicated intelligence, so institutions did the only thing available: they put the understanding in the middle and charged for it. The call center, the branch office, the claims department, the recommendation engine, the CRM that promises to know the customer. Every one of them is a smart switch. Every one of them completes its sentence from the middle of someone else’s channel.

Now intelligence is being installed at both positions at once. Institutions are bolting copilots into the middle of every app, every portal, every support channel — rebuilding the Intelligent Network with better grammar. And at the same time, quietly, the endpoints are arming: people are arriving with an AI of their own, one that holds their context, their constraints, their calendar, their meaning. The 1981 argument tells you which of these deployments can finish. What did I mean? and did it turn out right? are checks that run where the meaning and the outcome live. The vendor’s assistant can read every message you send it and still not know that the flight it helpfully rebooked destroys your Thursday, because your Thursday was never in its channel.

The middle AI is not doomed because it is bad. It is capped because it is misplaced — and its ceiling was published in 1984: a performance enhancement.

That is the consequence most people miss. The in-app assistant will often be genuinely useful, the way autocorrect is genuinely useful — fast, confident, right more often than wrong. But useful-in-the-middle has a ceiling, and the ceiling is “helper.” The completion of the function — knowing what was meant, confirming what came true — migrates to wherever the endpoint’s intelligence lives. Whoever owns the endpoint owns the function. The rest is carriage.

04Five predictions

1. Every smart channel ends as autocorrect.

   Tolerated, overridden, apologized for. The copilots being installed in the middle of apps will converge on the same social role your keyboard holds: a middle guessing at a meaning it cannot check. The most-used control on each of them will be the override, and users will learn exactly when not to trust them — the same way your thumbs learned.

2. The ends start running the check, and “done” changes owners.

   Today “done” is the vendor’s claim. It becomes your agent’s verification: the refund actually posted, the date actually moved, the document actually says what was agreed. Careful file transfer, applied to life. Disputes fall not because companies get kinder but because the check finally runs where the truth is.

3. Plain rails beat charming middles.

   Institutions split into two kinds: those exposing clean, machine-usable rails to the intelligent endpoints arriving at their door, and those building personality into the channel. The rails win on the only axes a middle can win — speed, reliability, neutrality. Boring becomes a strategy. The airline whose systems can simply be used beats the airline with the delightful assistant.

4. The middle gets paid like a middle.

   The premium currently charged for understanding-in-the-channel compresses toward carriage, because margin follows the function and the function is moving to the ends. The companies that accept this early — and price their rails like rails — keep the traffic. The ones that defend the premium meet the fate of the Intelligent Network: routed around.

5. The Intelligent Network gets rebuilt anyway — and fails the same way.

   Every few years, under a new name, someone with every incentive to believe the middle can know you will build the smart middle again. It will demo beautifully, because demos put the endpoint’s knowledge in the room. It will fail in deployment, because deployment does not. The position has not changed, and the position is the whole argument.

05Living at the endpoint

I have been running my working life from the endpoint for a while now — it is the whole premise of bringing your own AI and of owning your own record. This post is itself a small proof. The platform that hosts it never knows what it means; it delivers the bytes. And the last step of publishing it — every post, every time — is an end-to-end check: my AI fetches the live page and verifies that the words arrived intact before telling me it is done. Careful file transfer, forty-five years on. I did not adopt that discipline because the paper told me to. I adopted it because every time I trusted a middle to confirm its own work, I eventually typed an apology to someone named Anneke.

Already true

The argument and its track record are the record: the 1981–84 paper, Isenberg’s 1997 essay, and the fact that the network built on smart ends and a plain middle is the one you are reading this on. Personal agents already read what institutions send — your proposal has a second reader — and endpoint verification is already how this site ships.

What has to happen

Endpoints need durable intelligence of their own — a personal stack with memory and standing, not a borrowed login inside somebody’s portal. And institutions have to expose rails an agent can actually use: structured, accountable, boring. Both are underway; neither is finished.

Where I am probably wrong

Some functions genuinely live in the middle — fraud, spam, congestion are caught by the network’s vantage, not the endpoint’s, and the paper itself blesses the middle as an enhancement, which can be a very good business. The deeper risk: correctness does not decide markets, leverage does. A middle that owns passage can refuse the plain rail and tax the smart ends for a long time. If the tollbooths hold, this piece is right about the physics and early by a decade.