Systems design and the semantic revolution

When I was in high school in the 1990s, my physics teacher pulled me aside with a question he couldn’t shake: “How do they get every computer in the world to talk to every other computer?” 

He’d seen how hard it was to agree on basics like electrical outlets or phone dialing standards. Yet suddenly we had this internet thing where a machine in Thunder Bay could talk to one in Tokyo in milliseconds. No central planner. No global treaty. Somehow it just worked. 

The real answer is less magic and more mindset: a systems principle called Postel’s Law. 

In plain language: Be strict in what you send; be generous in what you accept. When I talk to you, I should do my best to follow the rules. When you listen, you should do your best to understand me even if I break them a bit. 

That philosophy, baked into early internet protocols, doubled our chances that any two systems would interoperate. Maybe the sender got it right. Maybe the receiver was extra tolerant. Either way, the network kept going. 

Over the last 30 years, we’ve tried to apply that same idea: Connect everything to everything, at higher and higher layers of the stack. It has not always been graceful. 

FIRST, WE TRIED TO STANDARDIZE SYNTAX 

In the 2000s, companies bet big on XML. The idea was simple: one universal format for sharing data, with a rulebook that spelled out exactly what every document should look like. In theory, software would just plug into that rulebook and everything would work automatically. In practice, the rulebooks became massive, the tools were brittle, and people spent a lot of time arguing about the rules. The money wasn’t wasted, though. Companies did the hard work to expose machine-readable APIs over HTTP instead of just shoving out web pages. That work mattered far more than XML itself, which quietly gave way to simpler formats like JSON. 

In the 2010s, we repeated the pattern with blockchains. The pitch this time: a distributed ledger that could track supply chains, invoices, and contracts in a standardized way everyone could verify. After billions of dollars and a lot of disillusionment, most companies kept the modernized infrastructure and quietly deleted the blockchain layer. Again, the technology fad wasn’t the real story. The real progress was that companies finally modernized their back-end systems and interfaces. 

NOW WE’RE STANDARDIZING SEMANTICS 

Large language models (LLMs), the systems behind tools like ChatGPT that many people now simply call “AI,” are different. They don’t just translate between file formats; they translate between meanings. 

Need to join two databases designed 10 years apart by teams who never met? Need to scrape a hostile web page and turn it into a clean product catalog? Need an English query to become a good SQL query across three systems? Yesterday that meant a human writing and maintaining a fragile adapter. Today an LLM can often generate that adapter, or even act as the adapter, on demand. 

You can argue about whether LLMs “understand” anything. You can’t really argue about whether they connect things. Given any two semi-coherent systems, an LLM will cheerfully try to map one to the other. It may be wrong or flaky, but it will try, constantly, at machine speed. 

That makes them the first practical technology to attack the hard 90% of integration: semantics. XML and friends tackled the easy 10%: syntax. 

THE CURSE OF SUDDENLY GETTING WHAT WE ASKED FOR 

Most executives I talk to still think about AI as a chatbot that writes copy or summarizes meetings. That’s the least interesting part. 

The important use case is what you might call B2B AI: LLMs calling your APIs, reading your docs, learning your quirks, and then turning around and calling your partners’ APIs. They are becoming the glue between CRMs, ERPs, ticketing tools, financial systems, often without a full-time integration project in sight. 

That’s great for time-to-value. It’s terrifying for everything else. 

The first internet boom gave us the joy of instant global connectivity and, as a side effect, botnets, malware, phishing, and whole new security industries: firewalls, VPNs, TLS, patch management, endpoint protection. We built them reactively, after the damage. 

Application-layer hyperconnection will follow the same pattern unless leaders move faster this time. If your LLM “integration layer” can talk to everything, then a misconfigured prompt, a compromised API key, or a poisoned training set can also talk to everything. 

SO WHAT DO YOU DO? 

Treat LLM-powered integrations as critical infrastructure, not prototypes. 

Insist on: 

• Clear system boundaries: Which systems can the AI read, write, or only suggest changes to? 

• Strong identity and access controls for every API it touches. 

• Audit trails that explain not just what happened but who or what decided this was a good idea. 

We connected all the computers once and spent decades building the safety rails afterward. Now we are connecting all the data and all the business logic. The adapters are smarter, but the lesson is the same: Postel’s Law will pull us toward connection whether we are ready or not. 

This time, let’s be ready. 

Avery Pennarun is CEO of Tailscale.