The Workaround Is the Pattern

In 1984, IBM released HLLAPI for its 3270 PC. The name, High Level Language Application Programming Interface, suggested something architecturally significant. What it did was let a program read the characters on a mainframe terminal screen the way a human operator would, position by position, 1,920 cells on a standard display. The program could type into fields and send keystrokes. It was a machine pretending to be a person sitting at a terminal.

This was not elegant. Move an error message three rows down and the integration broke. But the cooperative interfaces of the period, program-to-program protocols, middleware, database access layers, all required work on both sides of the connection. HLLAPI required work on one side only. The mainframe application neither knew nor cared. When the alternative is a rewrite nobody will fund, fragility is a price people will pay.

Cooperative integration existed the whole time, and by most technical measures it was better. But cooperation requires agreement, and agreement costs something: negotiation, coordination, maintenance carried by both parties, a continuing willingness to keep the connection alive. Those costs sort participants. Organizations able to carry them get structured, reliable connections. Everyone else gets nothing, or builds a workaround.

EDI, Electronic Data Interchange, was cooperative by definition: structured messages exchanged under bilateral agreements, with coding and formatting rules negotiated between the parties. It worked well for companies large enough to justify the overhead. A 2003 survey of small U.S. manufacturers found that 66% of adopters said trading partners had forced them into it. For a lot of participants, the cooperative design was experienced as a coercive one, and firms too small or too peripheral to justify the integration cost were left outside it entirely.

Then the web put information that had been locked inside proprietary networks in front of anyone with a browser, formatted for human eyes rather than machine consumption. The distance between what was visible on screen and what was actually machine-accessible created the same pressure HLLAPI had answered a decade earlier. In 1995, a research project called BargainFinder began submitting automated queries to online CD stores, extracting prices and assembling comparison tables. Three of the stores were blocking it within months.

The cooperative solutions that eventually arrived, APIs and developer programs and structured feeds, closed that gap while producing exclusions of their own: rate limits, tiered access, terms of service that one party could revoke, pricing that sorted applicants by what they could pay. Better than scraping in almost every respect, and still selective about who got in.

Now agents operate browsers. They fill in forms, click buttons, read screens, and pull information out of services that offer no API, or whose API does not expose the thing the agent needs. Four decades of technical progress separate this from HLLAPI, and it leaves the agent in the same position: treating a human-facing interface as a machine-readable surface because the cooperative alternative is either absent or doesn't serve.

The workaround returns not because cooperation failed but because it succeeded selectively. Each round of formalization draws a boundary, and the people outside the boundary still have work to do.

Something cooperative will grow up around agents too; it always does. The part worth watching is who that infrastructure admits and who it leaves outside, because the ones left outside are where the next workaround starts.