Blog/Article

Authorized Isn't Correct: What AI Agent Identity Can't Tell You

November 17, 2026 · 6 min read

One of Gartner's Top Strategic Technology Trends for 2027 is AI Agent Identity. The problem it addresses is real: agents act for many people at once, and they reach into legacy systems that were never built to grant access just in time. Gartner predicts that by 2028, 25% of enterprise security breaches will trace back to AI agent abuse, driven by unmanaged machine privileges and legacy credential practices.

Gene Alvarez, Distinguished VP Analyst at Gartner, described the answer this way: "AI agent identity connects models, prompts and credentials to agent actions, creating trust and accountability."

That is the right fix for the problem it names. Agent identity answers the question every security team has to answer: who is this agent acting for, and what is it allowed to touch?

It doesn't answer the question the CFO will ask: is this number right?

An agent can hold the correct credentials, query only the tables it is permitted to see, and still return revenue that is 2.7 times too high.

Authorized and wrong

Here is how, using a fan trap, a common grain error in analytics.

Say, for example, an agent is asked for revenue across two orders. The orders table holds one row per order, with the order amount. The order_lines table holds one row per item.

Order Order amount Line items
A $100 3
B $50 2

Actual revenue is $150.

The agent joins orders to order lines so it can filter by product category, then sums the order amount. Every order row now repeats once per line item. Order A's $100 appears three times, order B's $50 twice, and the sum comes back as $400.

SELECT SUM(o.order_amount) AS revenue
FROM orders o
JOIN order_lines l ON l.order_id = o.order_id;
-- returns 400, not 150

Nothing in that query fails. It runs, it returns a plausible number, and every table it touched was one the agent was authorized to read. The access log shows a well-behaved agent. The identity checks pass. The number is wrong.

A chasm trap is the same failure in a different shape: two fact tables joined through a shared dimension, so each multiplies the other's rows.

A wrong answer that looks right is worse than an error, because nobody goes looking for it. More on that in Your AI Agent's Queries Run Fine. That Could Be a Problem.

Correctness is a separate control

Access control and correctness control check different things. Identity, permissions and credentials decide whether an agent may run a query. None of them look at what the query means. A permission system can confirm the agent was allowed to read orders and order_lines. It has no way to know that joining them at the wrong grain nearly tripled revenue.

That check has to live somewhere that knows the business logic: the grain of each table, which joins are valid, how revenue is defined, and which definition has been approved. That is a semantic layer's job.

When an agent goes through a governed semantic layer, it doesn't write the join. It asks for revenue by product category. The semantic layer knows orders and order lines sit at different grains, and it catches fan traps and chasm traps and corrects them instead of returning a silently inflated number. The agent never gets the chance to make the mistake.

That protection covers the questions the semantic layer models. An agent that goes around it and writes SQL against raw tables is back to choosing its own joins. That is where MCP settings come in: Coginiti's MCP server can keep an agent on the semantic layer, so it asks for governed definitions instead of writing its own joins.

Gartner's list points the same way. Last month we wrote about another of its 2027 trends, AI Context Platforms, and why prioritizing semantics is what makes agents accurate. A third trend, Large Quantitative Models, starts from the observation that general-purpose language models carry accuracy and compliance risk on numerical work. Gartner predicts that by 2030, these models will replace LLMs in 25% of strategic forecasting and operational modeling tasks.

That is one answer: a different kind of model. For everyday business metrics there is an older one. The model shouldn't be computing revenue at all. It should be asking a system that already knows how revenue is defined. As we put it in May, your AI agent shouldn't define revenue, it should query it.

Both checks on every answer

Agent identity and semantic governance check different things about the same output. An agent's output should clear both before anyone acts on it.

Question about an agent's answer What settles it
Who was the agent acting for? Agent identity
Was it allowed to reach that data? Permissions and access control
Was the query at the right grain? The semantic layer
Is this the approved definition of revenue? The semantic layer, versioned, reviewed and tested
What produced this number, and what else depends on it? Lineage

Coginiti 26.10 brought the two sides closer. Domain-level permissions on the semantic layer let administrators decide which semantic domains a user or agent can reach, with APIs to provision access and inspect anyone's effective permissions. The MCP server supports OAuth for external clients, and administrators can set result limits so agent interactions stay bounded. Underneath, the semantic layer still does the part identity can't: it checks that a query is correct, not only that it is allowed.

Gartner is right that agents need identities. Once an agent has one, the next question about its answer is the one identity can't settle: is it right?

See how Coginiti checks agent queries for correctness: request a demo

Sources

See Semantic Intelligence in Action

Coginiti operationalizes business meaning across your entire data estate.