Machine-Readable Isn't Machine Understanding — And That Used to Be Fine

I Heard Everything. I Understood Almost Nothing.

When I first worked in Germany, I didn’t speak German.

In meetings, I could hear everything clearly. The words were crisp. Some even sounded familiar — Projekt, Meeting, Deadline.

But hearing isn’t understanding.

So I guessed. I watched body language. I listened for tone. I stitched together meaning from the few words I recognized and the context around them. Sometimes I guessed right. Sometimes I nodded along to something completely wrong.

But here’s the important part: I knew I was guessing.

So when it mattered, I stopped and asked: “Wait — did you mean X or Y?”

That pause saved me from making bad decisions.

AI agents don’t do that. They parse perfectly. They infer meaning from patterns. And then they act — confidently, instantly, without raising their hand.

That’s the problem.

Fluency Is Not Understanding

Consider this:

{ "amount": 2000 }

Yes, a language model can infer from context that this is probably dollars, probably a price, probably belongs to someone. LLMs are remarkably good at this kind of pattern-matching — they’ve seen millions of similar payloads.

But inference isn’t knowledge. The model doesn’t know — it guesses well.

And when the context is ambiguous, when the API is internal, when the conventions are non-standard? Now it’s guessing — and you don’t find out it was wrong until something breaks.

The parser sees structure. The model sees patterns. Neither sees meaning — unless someone wrote it down.

The Question Nobody Needed Answered (Yet)

In the late 1990s, Tim Berners-Lee and others asked a strange question:

How do machines know what data means, not just what it contains?

They weren’t talking about parsing. XML already parsed. JSON would soon parse. That problem was solved.

They were talking about semantics — meaning.

So they built an ambitious stack: RDF for representing knowledge as relationships. Ontologies for shared vocabularies. SPARQL for querying based on meaning, not structure.

The vision was bold: machines wouldn’t just move data — they would understand it.

Why the Semantic Web “Failed”

Semantic technologies didn’t fail — they succeeded where meaning mattered. They just never became the default web architecture, because humans were always there to interpret the data.

Here’s how systems actually worked for decades:

System A → JSON → Developer → Code → System B
                      ↑
                "I know what this means"

The developer read the docs. The developer understood the domain. The developer encoded meaning into logic.

Humans were the semantic layer.

As long as humans were always in the loop, the cost of making meaning explicit — RDF graphs, ontologies, triple stores — was higher than the benefit. The Semantic Web felt academic. A solution looking for a problem.

The problem just hadn’t arrived yet.

The Human Who Knew Isn’t There Anymore

Then AI agents entered the loop.

System A → JSON → AI Agent → Action
                      ↑
                "I'll figure it out"

No developer interpreting the data. No hard-coded business rules. No one stopping to ask clarifying questions.

We now hand machines data and say: “Process this payment.” “Update this customer.” “Decide what to do next.”

The agent parses the JSON perfectly. That was never the problem.

I ran into this firsthand while wiring AI agents to OpenAPI specs through an MCP adapter. The schema was correct. The types were precise. Every field was documented. The API was perfectly machine-readable.

And the agent still didn’t actually understand what it was doing.

It knew what it could call, but not when it should. It knew the shape of the data, but not the meaning behind it — what was safe, what was expected, or what assumptions a human would automatically make. Without that missing context, the agent wasn’t reasoning. It was guessing.

{
  "amount": 2000,
  "status": "requires_action",
  "customer": "cus_123",
  "account": "acct_456"
}

The agent must now infer: Is 2000 dollars or cents? Is requires_action an error or a normal workflow state? Is customer the payer or the recipient?

The human who knew the answers isn’t there anymore.

So the agent does what language models do best: pattern-matching. Sometimes it guesses right. Sometimes it charges $2,000 instead of $20. Sometimes it retries something that should never be retried.

And it does all of this confidently.

The Gap Reopens

For years, this worked:

Era	Who parsed	Who understood	Gap filled by
Pre-AI	Machine	Human developer	Human-written logic
AI Agents	Machine	???	Inference (guessing)

The gap between parsing and meaning is back. And inference is filling it — fast, confident, and sometimes catastrophically wrong.

This is the exact problem the Semantic Web was trying to solve.

The Old Answer Becomes Urgent

The Semantic Web’s core insight was never about RDF syntax or SPARQL queries. It was this:

Don’t make machines infer meaning. Make meaning explicit.

That’s it.

Implicit:  { "amount": 2000 }
Explicit:  { "amount": 2000, "unit": "cents" }

When meaning is implicit, machines must guess. When meaning is explicit, machines can read.

How you do this matters less than doing it at all:

Better field names: amount_in_cents
OpenAPI descriptions: “Amount in cents. 2000 = $20.00 USD”
Structured metadata: { "value": 2000, "unit": "cents" }
JSON-LD: { "@type": "MonetaryAmount", "unitCode": "CENT" }

Different formats. Same principle: here’s what this data means.

Why Semantics Still Matter (Even If AI Doesn’t “Reason” Over Them)

Let’s be direct: most AI agents don’t load triple stores, run SPARQL queries, or reason over ontologies in the classical sense. They read JSON-LD and RDF as text.

But that’s precisely why explicit semantics help.

They force humans to write down meaning. They provide shared vocabulary. They make relationships explicit instead of implied.

The AI doesn’t become smarter. It just stops guessing.

When This Matters Most

If you’re calling Stripe, the model has probably seen it before. If you’re calling your internal billing service from 2015 — it’s guessing.

What This Means For You

If You Build APIs

If an AI agent will touch your API, your data must answer these questions explicitly:

What is this value?
What unit is it in?
What entity does it belong to?
What actions are valid?

Start small:

amount:
  type: integer
  description: "Amount in cents. 2000 = $20.00 USD"

Escalate only when necessary: better descriptions, better names, structured metadata, semantic formats for complex domains.

If You Build Agents

Do not rely on inference for irreversible actions.

Inject context deliberately
Validate before acting
Add human review where failure matters

Inference is powerful. It is not understanding.

The Principle

For 25 years, the answer to “How do machines know what data means?” was: they don’t need to. Humans handle that.

That answer no longer holds.

AI agents parse your data, infer meaning, and act on that inference. When they infer wrong, they fail silently — and confidently.

The Semantic Web wasn’t wrong. It was early.

Write down what your data means.

Because the human who used to know? They’re not in the loop anymore.

As Tim Berners-Lee and colleagues argued in their original vision of the Semantic Web, the effectiveness of software agents depends on the availability of machine-readable content with explicit semantics — without which agents cannot reliably cooperate or act.

Originally published on LinkedIn.