Why AI agents fail: they don't understand your business

A mounting problem across every enterprise

Enterprise AI isn't failing because the models aren't good enough.

It’s failing because the models don't understand the business they're operating in.

Across boardrooms and engineering standups alike, the conversation tends to revolve around the same questions: Are we using the right model? Are our prompts good enough? Is our infrastructure scaling?

Those are reasonable questions. But they’re not the right ones.

The missing ingredient is context. More specifically, governed context: what your data means, whether it can be trusted, and what AI is permitted to do with it. Everything else follows from that.

Gartner predicts that more than 40% of agentic AI projects will be canceled by the end of 2027. That's a staggering number, and I'd argue almost none of those failures will be model failures. The models are working. The problem is that the data and context those models are operating on was never fit for purpose and nobody built the governance layer to make it so.

Anthropic recently put a number on this. In its own evaluation, analytics agents operating on raw, ungoverned data answered correctly less than 21% of the time. When they were governed with business context, accuracy climbed above 95%. That gap from 21% to 95% isn’t a model gap. It's a governance gap we call the hallucination tax, and it's costing enterprises far more than they realize.

Organizations today are scaling AI faster than they're building the context AI needs to operate reliably. That’s where projects begin to break down.

What "context" actually means in enterprise AI

When an AI agent is deployed in your enterprise, it doesn't understand your data the way an experienced analyst does. It pattern-matches on it. Before it takes any action, it has to be able to answer three questions:

1. What does this data actually mean?
2. Is this data trustworthy right now?
3. What am I allowed to do with it?

If an agent can't answer all three reliably, it's guessing. And that’s dangerous for everyone involved.

For example, “customer” seems straightforward. But at a financial institution, "customer" likely means a regulated entity with specific know your customer (KYC) requirements, compliance obligations and a variety of access restrictions. At a retailer, "customer" might mean anyone who's ever made a purchase. This is a very different definition with very different implications for how data about them should be handled.

An AI agent that doesn't know which definition applies has a context problem.

Why enterprises get this wrong

Most enterprises are approaching this exactly backwards. They're connecting AI agents directly to data including ungoverned data lakes, raw pipelines and siloed systems with the hopes the models will sort it out. They won't.

When agents hit ungoverned data without the proper context, they guess, leading to compounding consequences including bad outputs, sensitive data exposure and the loss in confidence for both customers and employees alike.

This has a real cost: the hallucination tax. Every wrong answer generates wasted tokens on outputs that have to be discarded or corrected. Every flawed output triggers manual review. At five agents, manual review is annoying but manageable. At twenty, it becomes a budget line item. At fifty, it's a program risk that threatens the entire AI initiative. The hallucination tax doesn't scale in a linear fashion; it compounds as agents multiply, and most leaders don't see it coming until it's already a crisis.

Meanwhile, data teams are caught in a different kind of trap. They keep rebuilding definitions that already exist somewhere or that once existed before they drifted. Semantic definitions multiply across domains with no agreed source of truth. Your North America "revenue" isn't Europe "revenue". Your Product team’s "active user" contradicts Sales Operations. Nobody can find the authoritative definition, so everyone creates their own. The result is an enterprise that can't agree on what its own data means.

And then there's the reality of infrastructure. Enterprises don't run on a single cloud. They run on sprawling, hybrid, multi-platform ecosystems: Snowflake, Databricks, BigQuery and SAP next to Salesforce, Tableau and Power BI feeding decisions, with on-premise systems in the mix (we still have customers using mainframes to this day). Each platform has its own metadata conventions, its own permission models, its own idea of what a "customer" is. There is no natural layer that unifies them, unless you build one.

There's a dimension to this problem that rarely gets enough attention: unstructured data. Eighty percent of enterprise data is unstructured: contracts, research, meeting notes, support tickets, and it’s where the most proprietary, differentiated context often lives. It's also the hardest to govern, so it gets excluded from governance programs entirely. Which means the institutional knowledge that gives your business its edge is precisely the context your agents can’t access.

The result of all of this is predictable: bad outputs, exposed data and AI projects that never make it out of pilot. Not because the AI failed, but because the context wasn't there.

A tale of two agents

Imagine a bank with retail customers, commercial accounts, and a wealth management division deploying an AI agent to support loan officers. The agent's job: pull together a client's full financial profile when a loan officer opens a case, surface relevant risk signals, and recommend the next best action.

Without context governance, the agent connects directly to the bank's data lake. It queries a table called “customer_accounts” and returns a list of accounts. But "account" means different things in different parts of the bank. A retail checking account, a commercial credit facility, and a managed investment portfolio are all stored under the same label, with no metadata distinguishing them. The agent doesn't know this. It’s also unaware that one of the accounts belongs to someone the compliance team flagged last quarter, because that information sits in an unstructured document in a SharePoint folder the agent can’t access. The agent surfaces the data, the loan officer sees a clean profile, and a loan moves forward that should have triggered a compliance review. The issue isn't discovered until an audit three weeks later. The cost of remediation, regulatory review, and reputational damage far outweighs any efficiency the AI created.

Meanwhile, another loan officer asks the same agent about a client's "net worth." The agent returns a number from the wealth management system. But that system calculates net worth using a definition that excludes certain held assets, has been locally modified and never reconciled with the enterprise standard. Neither the loan officer nor the agent know this. The recommendation it generates is based on a number that's wrong in a way nobody flagged.

The hallucination tax isn't always a model confidently stating a false fact. Sometimes it's a model confidently returning a real number that means something different than everyone assumes.

With context governance, the same agent operates entirely differently. When it queries customer accounts, it calls a governed data product. The product carries not just the data, but the semantic definitions for each field. "Account type" is resolved against the enterprise-wide taxonomy, which distinguishes retail, commercial and investment accounts with precision. The agent knows what it's looking at.

The compliance flag from last quarter isn't buried in an unstructured document, it's been ingested, tagged and linked to the customer record in the governed context layer. When the agent pulls the client's profile, the flag surfaces automatically, along with the policy that governs what the loan officer is permitted to do next. The agent doesn't guess at permissions, it enforces them.

When the loan officer asks about net worth, the agent retrieves the figure and returns it with a note: “This value uses the wealth management division's local definition, which excludes certain held assets. See the enterprise standard for a reconciled figure.” The loan officer has what they need to make an informed decision, not a confident wrong answer.

Same agent, model and underlying data with radically different outcomes due to governed context.

This is not a theoretical future state. It's the difference between an AI program that scales and one that stalls, between a CFO who sees AI as an asset and one who's quietly calculating the cost of cleaning up after it.

What is context governance?

This brings me to the concept that I believe will define the next phase of enterprise AI: context governance.

Context governance is the practice of making enterprise context (meaning, trust, and permission) reliable so AI agents can reliably act on it.

I want to be direct about something: context governance is not traditional data governance with a new name.

Traditional data governance was built for humans navigating data systems, ensuring data is accurate, consistent, compliant. We’ve spent nearly two decades building Collibra on that foundation.

But agents don’t work like people. They make decisions in milliseconds using information they can’t question or interpret on their own. Governed data isn’t enough. They need governed context.

Context governance extends beyond traditional data governance to address everything an agent needs before it acts: unstructured data, semantic definitions, ontological relationships and runtime policy enforcement. Data governance was built for humans. Context governance is built for agents. Governed context is what gives enterprises control over AI.

The architecture matters here. There are two foundational layers:

A semantic layer tells the agent what each word means. "Revenue" in the context of this domain means a very specific definition, not one of the seventeen that exist across your business units.

An ontology tells the agent how meaning, trust and permission connect. Ontology is the structural relationships between concepts. An agent that understands this doesn't just know what a customer is, it knows what it's allowed to do when it encounters one, and why.

In practice, this means an agent doesn't query raw data and hope for the best. Instead, it calls a governed data product: a curated asset that delivers data together with its meaning, lineage, and policy. That's the difference between an agent that guesses and one that reasons.

Together, these layers give AI agents what they need to move from pattern-matching to genuine, reliable reasoning over your enterprise data.

Context governance isn't a one and done project

Here's something the Anthropic data exposed that I don't think the industry has fully absorbed: accuracy fell from 95% back to 65% within a month of governance lapsing. Definitions drift. Data freshness lapses. Permissions change. The semantic layer you built last year (or even last month) may not reflect how your business operates today.

If you ran a semantic layer project two years ago and think you're covered, you're not. Context governance isn't a one-time project. It's a continuous practice. The question isn't whether you've defined your terms. The question is whether those definitions are still accurate, still enforced, and still reaching your agents in real time.

This is also where the feedback loop matters. Agents use context, and that usage exposes gaps including terms that weren't defined, relationships that weren't mapped and policies that weren't enforced. Good context governance captures those gaps and closes them. That loop compounds over time, and isn’t something you can build from only one side. A vendor that only provides data tools without governance, or governance tools without data integration, can't close that loop for you. The flywheel only spins when both sides are connected and working in harmony.

Three questions every leader should ask this week

The enterprises that will win with AI are not the ones with the most sophisticated models. They'll be the ones that establish context governance as the prerequisite for scale and treat AI control as the strategic infrastructure.

Before you greenlight your next agent, or wonder why the current ones aren't performing, ask your team three questions:

1. Can every AI agent in production answer what each piece of data it touches actually means? If the answer involves a spreadsheet someone maintains manually, or "it depends on which team you ask," you have a context governance problem.
2. What is your hallucination tax? Add up the manual review hours, the discarded outputs, the tokens burned on wrong answers. If you don't know the number, find it. It's there, and it's growing as you add agents.
3. When did your semantic definitions last get validated? If it's been more than a quarter, your agents are operating on context that has already started to decay.

Context governance is how you take control of AI at enterprise scale. We've spent nearly two decades building Collibra because I believe that data, and now AI, can only be trusted if it's properly governed. That conviction hasn't changed. If anything, the rise of agentic AI has made it more urgent.

That's what we're building at Collibra.

• 

  Felix Van de Maele

  Felix Van de Maele

  Founder, CEO

  Collibra