Why AI agents give inconsistent answers — and the semantic layer they're missing

OpenAI just previewed a model that can plan and execute across a hundred-step agentic task. It still can’t tell you whether your two systems mean the same thing by “active customer.”

That gap is the whole story of enterprise AI in 2026. The reasoning got better. The data underneath it still doesn’t agree with itself.

TL;DR: A semantic layer for AI agents is the governed, machine-readable place where terms like “active customer,” “on-hand,” and “complete” are defined once, so every agent resolves them the same way. TDWI’s 2026 benchmark found only 27% of organizations have one. That’s why agents give confident, inconsistent answers about a company’s own data — two systems carry two definitions, and the agent inherits whichever it queried. A stronger model, like the GPT-5.6 family OpenAI previewed in June 2026, reasons faster over that ambiguity; it doesn’t resolve it. Define the terms first, make drift fail loud, then turn the agent on.

The model got better. The definitions didn’t.

On June 26, 2026, OpenAI previewed GPT-5.6 Sol, built for frontier reasoning and long-horizon agentic work — an “ultra” mode that splits complex jobs across subagents, a new state of the art on the Terminal-Bench 2.1 multi-step benchmark. It’s a real jump in what a single agent can plan and carry out.

Here’s what none of that touches. Ask that model, running as an agent inside your company, “how many active customers do we have,” and the answer depends on which system it reads. Your CRM says active means logged in within 90 days. Billing says active means holding an unexpired contract. Both are internally correct. Neither is the company’s answer, because the company never wrote one down. The smarter model doesn’t help here — it just returns the wrong-for-your-purposes number with more composure.

This is the part the model launches keep skipping. Reasoning was never the layer that was broken. Meaning was.

The named object under every “data contract”

I’ve written before that integration and data contracts decide whether AI works, and that agentic planning breaks when your systems don’t agree on a number. The semantic layer is the thing those pieces were circling. It’s the actual architectural object: one governed, machine-consumable place where each business term has a single definition, sitting between the raw systems and every agent that reads them.

Without it, the definition doesn’t disappear — it scatters. It lives in a SQL view one analyst wrote in 2023, in a field label that means one thing in Salesforce and another in NetSuite, in the head of the ops manager who knows “complete” means dispatched in the field app but invoiced in finance. Each system carries its own quiet version. An agent querying across them doesn’t get a contradiction it can flag. It gets one answer, confidently, from whichever table it happened to hit.

A human analyst catches this. They know to ask “active by which definition?” The agent doesn’t ask. It answers. And an agent acting on a term it silently misread isn’t automation — it’s a faster way to be wrong, at a scale no one is reviewing.

Four 2026 reports, one finding

This isn’t a hunch. Independent data-readiness studies published across 2026 land on the same number from different angles, and it’s not about model quality.

Source (2026)	Sample	The finding
TDWI Agentic AI Readiness Benchmark	161 organizations	27% have a governed, enterprise-wide semantic layer that’s machine-consumable; 47% report broadly trusted structured data; fewer than 10% run multi-agent systems in production
Fivetran Agentic AI Readiness Index	400 data professionals	15% fully prepared to support agentic AI in production, while 41% already run it there; 42% name data quality and lineage the top barrier
Modern Data Report	540+ practitioners	80% rank a semantic layer with standardized definitions as the single most important enabler of AI — above AI tools themselves; 68% say their data isn’t reliable enough for AI
Google Cloud (Next 2026)	Vendor product	Shipped Knowledge Catalog to give agents “trusted business definitions and relationships they’ve previously lacked”

Read the columns together and the picture is blunt. A large majority of enterprises are pushing agents toward production faster than their data can define itself. TDWI’s own framing is that the imbalance — data and definitions lagging while ambition races ahead — is exactly where agentic initiatives stall.

The last row is the tell. When Google Cloud rolled out its Knowledge Catalog in April 2026, it described the problem in its own words: “AI is only as smart as its context. If an agent doesn’t understand your definition of ‘margin’ or the intricate relationships in your supply chain, it’s forced to guess.” That’s a hyperscaler conceding, in a launch, that the missing piece was never the model. It was the shared definition. When the vendors selling you the agents start selling you the semantic layer, the argument is over.

Why “forced to guess” is the expensive part

Guessing sounds harmless until you follow it downstream. A retrieval or planning agent doesn’t return “I’m not sure which definition you mean.” It returns a number, a routing decision, a drafted approval — as if the definition were settled. The error doesn’t announce itself. It rides quietly into a board deck, a customer-facing promise, a replanning loop that runs every fifteen minutes on a figure two systems compute differently.

And it degrades silently over time. Someone renames a CRM stage from “Closed Won” to “Committed.” The connector still fires. The agent still runs. But the field it was counting now means something subtly different, and nothing in the stack notices, because a schema that still validates can carry a meaning that quietly drifted. Three vendors in the pipeline, three definitions of the same event, and no one owns the reconciliation — so the number just gets wrong, and stays wrong, and gets cited.

That’s the failure the freshest model can’t save you from. GPT-5.6 reasoning over undefined terms is still reasoning over undefined terms.

The working version: define, then deploy

The fix isn’t a bigger model or a wait for one. It’s unglamorous and it’s the entire job.

Define the terms the agent acts on — in a place a machine can read. Not a wiki page. Not tribal knowledge. Pick the decisions the agent will actually make, list the handful of terms those decisions turn on — active customer, on-hand, complete, margin, past due — and resolve each to one governed definition. You don’t need to model your whole enterprise. You need the terms in the agent’s path.

Decide which system wins. When the CRM and billing disagree on “active,” the semantic layer names the authoritative source and the rule. That decision is a business call, not a data-engineering one — which is exactly why it keeps not getting made, and exactly why the agent keeps guessing.

Make drift fail loud. When an upstream field is renamed or a value changes meaning, the pipeline should stop and flag, not keep answering with a definition that silently shifted underneath it. A loud failure is a ticket. A silent one is a number in a report that no one questions until it’s expensive.

Start narrow, with a human on the output. One workflow, one set of defined terms, someone checking the agent before it acts. Earn the autonomy on data you’ve actually defined.

The organizations getting agents into production aren’t the ones who bought the strongest model. Per TDWI, fewer than one in ten are running multi-agent systems in production at all — and they’re not the ones who reasoned hardest. They’re the ones who wrote down what their own words mean before they let an agent act on them.

A better model reasons faster over data it misunderstands. Making that data legible to a machine is the work worth doing first — and it’s the conversation worth having before the next agent goes live.