The Same Gap, Three Times

Every generation of automation solves the previous generation's fragility, and then discovers its own version of the same one.

In the early 2000s, an engineer named Gregor Hohpe was connecting state agency systems running on IBM mainframes. The only way in was through EHLLAPI, an API that let software pretend to be a person sitting at a terminal. The screen was an 80-by-25 character grid. To extract a piece of data, you told your script exactly where to look: row 14, column 32. If a mainframe developer added a field above row 14, the script would silently read the wrong value.

Hohpe's fix was to build a small language on top of the coordinates. Instead of hardcoding positions, his scripts could find a label like "ADDRESS" and grab the next field. "If the screen layout ever changed," he wrote, "all I would have to do was edit the script."

That sentence is worth sitting with. Not the failure. The expectation of failure, designed around.

Twenty years later, the interface had moved from a character grid to a web browser. The automation layer had a new name: robotic process automation. RPA bots didn't read row/column coordinates. They read CSS selectors, window handles, button positions. A practitioner at ClaySys described the canonical failure mode: an RPA bot set up to click a sign-up button in the top-left corner of a page works perfectly until someone moves that button to the middle. The bot keeps looking where it was told to look.

The coupling mechanism had changed — from coordinates to selectors — but the coupling was identical.

A Fortune 100 company documented what happens when these layers stack. They had years of ad-hoc macros scraping mainframe screens. To bring order to the chaos, they deployed RPA on top. One bot ended up hitting the mainframe nearly 7,000 times to complete a single task, running terminal transactions faster than any human would, until the mainframe ground to a halt. The new automation layer consumed the old interface more aggressively than any human operator ever had. RPA inherited the green screen's geometry and then automated it at a speed the green screen was never designed to absorb.

And then the automation layer changed again. AI browser agents don't read CSS selectors. They interpret the page the way a person might: labels, layout, visual context. An agent that understands "this is a search field" is genuinely more resilient than a script that knows div.search-input-v3. Genuinely more resilient, and still reading an interface that was built for someone else.

The primary benchmark for evaluating these agents, WebArena, uses frozen, self-hosted websites. The environments are static specifically because live web interfaces change in ways that make results unreproducible. When researchers at WAREX tested agents under environmental variation, agents that performed well under default conditions showed "severe degradation."

The bridge is more sophisticated now. Probabilistic reasoning where there used to be coordinate maps. Visual understanding where there used to be element IDs. The gap underneath hasn't changed: interfaces designed for human perception, read by machines that were never the intended audience.

Hohpe built a scripting language to manage the expectation that screens would change underneath his automations. The WebArena team built frozen websites to manage the expectation that pages would change underneath their agents. Fifty years apart, both designing around the same thing.