<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Ganesh Raju | Enterprise AI, Agentic AI & AI Governance]]></title><description><![CDATA[Enterprise AI insights from Ganesh Raju, CAIO and CTO in Houston: agentic AI architecture, AI agent security and governance, SAP and ERP AI, digital twins.]]></description><link>https://ganeshraju.hashnode.dev</link><image><url>https://cdn.hashnode.com/uploads/logos/6aff50a9bfa6af59fb6e4e7d/a52ffbed-a40a-45ca-b075-d70663f75ae5.png</url><title>Ganesh Raju | Enterprise AI, Agentic AI &amp; AI Governance</title><link>https://ganeshraju.hashnode.dev</link></image><generator>RSS for Node</generator><lastBuildDate>Fri, 20 Nov 2026 16:42:31 GMT</lastBuildDate><atom:link href="https://ganeshraju.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[RAG, CAG and KAG: Choosing How Enterprise AI Uses What the Business Knows]]></title><description><![CDATA[RAG, CAG or KAG? A CAIO's guide to what the research shows, token costs, governance and a hybrid knowledge architecture that routes each question.]]></description><link>https://ganeshraju.hashnode.dev/rag-cag-and-kag-choosing-how-enterprise-ai-uses-what-the-business-knows</link><guid isPermaLink="true">https://ganeshraju.hashnode.dev/rag-cag-and-kag-choosing-how-enterprise-ai-uses-what-the-business-knows</guid><category><![CDATA[RAG ]]></category><category><![CDATA[knowledge graph]]></category><category><![CDATA[llm]]></category><category><![CDATA[Artificial Intelligence]]></category><category><![CDATA[AI]]></category><dc:creator><![CDATA[Ganesh Raju]]></dc:creator><pubDate>Fri, 20 Nov 2026 14:47:41 GMT</pubDate><content:encoded><![CDATA[<p><em>A CAIO's perspective on enterprise knowledge architecture. Full whitepaper (PDF, 29 pages, 11 figures):</em> <a href="https://doi.org/10.5281/zenodo.24399422"><em>DOI 10.5281/zenodo.24399422</em></a><em>.</em></p>
<h2>Executive summary</h2>
<p>Across energy, manufacturing, healthcare and financial services, I keep seeing the same pattern. The model is rarely the problem. Enterprise assistants disappoint because the right business knowledge is not in front of the model when it answers, or because nobody can prove the model was allowed to see what it used. RAG, CAG and KAG are three ways of solving the first problem; governance decides the second. For a CAIO or CTO, choosing between them is less a technology bet than a decision about where knowledge preparation happens, who owns it, and what each correct answer costs.</p>
<ul>
<li><strong>RAG (Retrieval-Augmented Generation)</strong> searches a document collection when a question arrives and passes the model the few passages that matter. It is the usual starting point because it copes with large collections, frequent change and per-user permissions.</li>
<li><strong>CAG (Cache-Augmented Generation)</strong> loads a small, stable body of knowledge into the model once, keeps the model's processed state (the KV cache) and reuses it for later questions. It can work well for a shared handbook that is queried all day. It does not suit large, fast-changing or permissioned content.</li>
<li><strong>KAG (Knowledge-Augmented Generation)</strong> first turns documents into a graph of entities and relationships linked back to the source text, then answers by planning and running a sequence of lookups and calculations. It earns its higher cost on questions that chain several facts, depend on dates, or apply rules.</li>
</ul>
<p>Mature programs do not pick one. They build a single governed knowledge platform and route each kind of question to the cheapest path that answers it reliably. That is the direction I recommend, and the rest of this article explains how to get there without overinvesting early.</p>
<h3>What leaders should take from the research</h3>
<ul>
<li><strong>Most headline numbers do not survive a reading of the papers.</strong> CAG's famous "40x faster" is measured against re-reading the whole corpus for every question, not against RAG. Its accuracy edge over RAG is marginal and disappears as the content grows.</li>
<li><strong>Graphs are an investment for specific questions, not a general upgrade.</strong> Graph methods win on questions that chain facts, dates and rules, and lose to plain retrieval on simple lookups.</li>
<li><strong>Bigger context windows do not retire retrieval.</strong> Models lose accuracy well before their advertised limit, especially when the answer is not phrased like the question.</li>
<li><strong>No approach is reliable on its own.</strong> Even the best systems in public benchmarks miss or get wrong a meaningful share of questions. Evaluation, and the ability to say "I don't know", belong in the design from day one.</li>
</ul>
<h3>Five recommendations for the next twelve months</h3>
<ol>
<li><strong>Fix retrieval before buying anything new.</strong> Contextual chunking, hybrid search and reranking cut retrieval failures by more than half in published tests, and most production systems I review have not done all three. This is the cheapest accuracy gain available.</li>
<li><strong>Turn on caching where the terms fit, and make CAG earn its place.</strong> Prefix caching is close to free money for stable instructions. For small, stable, shared content, run CAG side by side with a well-tuned RAG pipeline before committing.</li>
<li><strong>Fund a graph only where real questions demand it.</strong> Look at what users actually ask. If enough of it is relational, time-bound or rule-bound, start with low-cost graph methods and reserve KAG for rule- and calculation-heavy domains such as compliance, claims or engineering change.</li>
<li><strong>Route rather than choose.</strong> A router lets each path be justified, measured and retired on its own business case, which is how you avoid a platform built around last year's favourite technique.</li>
<li><strong>Govern all three paths the same way.</strong> Authorize before any knowledge reaches the model, isolate caches per tenant, track where every fact came from, and report cost per correct, authorized answer to the business, not cost per token.</li>
</ol>
<p>The picture below shows where this article lands: one governed platform in which RAG, CAG and KAG are options chosen by an orchestration layer.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/c704d3cb-899f-4a97-aaaa-f4eb8c640b9a.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 1. Enterprise knowledge architecture: applications on top, an orchestration and knowledge router choosing RAG, CAG or KAG, and a governed knowledge fabric over enterprise data sources.</em></p>
<h2>Part I — Concepts</h2>
<h2>1. Why LLMs need external knowledge</h2>
<p>When I brief a board, I describe a language model as a brilliant new hire who studied everything public up to a certain date and then stopped reading: fluent and fast, but unaware of your company, your latest policies, and anything that happened since.</p>
<h3>What a model "knows" — and what it cannot</h3>
<p>Everything a model learned in training is stored in its weights. Researchers call this <strong>parametric memory</strong>. It has three limits that matter to every enterprise:</p>
<table>
<thead>
<tr>
<th>Limit</th>
<th>What it means in practice</th>
<th>Example</th>
</tr>
</thead>
<tbody><tr>
<td><strong>Frozen in time</strong></td>
<td>The model knows nothing after its<br />training cutoff</td>
<td>It cannot tell you last quarter's<br />revised pricing</td>
</tr>
<tr>
<td><strong>Never saw</strong><br /><strong>your data</strong></td>
<td>Contracts, maintenance logs, SOPs,<br />customer records were never in<br />training</td>
<td>It cannot answer "what is our<br />warranty term for Product X?"</td>
</tr>
<tr>
<td><strong>Cannot cite</strong></td>
<td>Even a correct answer arrives<br />without a source</td>
<td>An auditor cannot verify where<br />the answer came from</td>
</tr>
</tbody></table>
<p>When a model lacks the relevant facts it will often still produce a fluent, confident answer. Unsupported answers of this kind are called <strong>hallucination</strong>.</p>
<h3>The open-book exam</h3>
<p>The fix is to turn a closed-book exam into an open-book one: give the model the relevant pages at the moment it answers, and ask it to answer from those pages and cite them. That is the idea behind RAG, first published by Facebook AI researchers in 2020. Knowledge lives in a searchable index outside the model, where it can be updated without retraining.</p>
<p>In public benchmarks, giving a model the right documents lifts accuracy substantially, yet even the best systems still miss a meaningful share of questions. External knowledge is the difference between a model that guesses and one that grounds its answers. How you deliver that knowledge, and how you govern it, decides whether the result is enterprisegrade.</p>
<h2>2. The three approaches, explained simply</h2>
<p>All three approaches answer the same question — <em>how does the right knowledge reach the model?</em> — but they do it at different times and in different forms: RAG fetches it when asked, CAG prepares it in advance, and KAG organizes it into connections first.</p>
<h3>An everyday analogy</h3>
<p>Imagine three ways to help an expert answer customer questions:</p>
<ul>
<li><strong>RAG is the research librarian.</strong> Every time a question arrives, the librarian searches a huge, constantly updated library, pulls the three or four most relevant pages, and hands them to the expert. It copes with very large libraries and stays current as long as new and changed documents are indexed promptly. But if the librarian grabs the wrong pages, the expert answers from the wrong pages.</li>
<li><strong>CAG is the open binder on the desk.</strong> For a small, stable reference — say a 150-page product handbook — the expert reads it once in the morning and keeps it open. Every question that day is answered without fetching anything. Fast and simple, but only works if the binder is small, does not change during the day, and everyone asking is allowed to see all of it.</li>
<li><strong>KAG is the investigator's evidence board.</strong> Before any questions arrive, an analyst pins every person, company, contract and event to a board and draws the connections between them, each string labelled and tied to a source document. Questions like "which suppliers of Plant A have contracts expiring within 90 days?" are answered by following the strings. Powerful for connected questions, but building and maintaining the board is real work.</li>
</ul>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/34dfc772-f654-482c-9692-3e8c0deab912.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 2 · the three approaches as everyday analogies</em></p>
<p>Read each column top to bottom: the difference is <em>when</em> the knowledge work happens — at question time (RAG), once in advance (CAG), or as a map built in advance and walked per question (KAG). The same colours mark the three approaches in every diagram that follows.</p>
<p><strong>The same idea in one table</strong></p>
<table>
<thead>
<tr>
<th></th>
<th>RAG</th>
<th>CAG</th>
<th>KAG</th>
</tr>
</thead>
<tbody><tr>
<td>In one phrase</td>
<td>Find what is relevant</td>
<td>Reuse what is<br />prepared</td>
<td>Connect facts, then<br />reason</td>
</tr>
<tr>
<td>When<br />knowledge is<br />selected</td>
<td>At question time</td>
<td>Ahead of time, once</td>
<td>Ahead of time (the<br />graph), then planned<br />at question time</td>
</tr>
<tr>
<td>Form the<br />knowledge<br />takes</td>
<td>Retrieved text<br />passages</td>
<td>The model's saved<br />"reading" of the<br />whole corpus (KV<br />cache)</td>
<td>Entities, relationships<br />and rules, linked back<br />to text</td>
</tr>
<tr>
<td>Best for</td>
<td>Large, changing,<br />permissioned libraries</td>
<td>Small, stable, shared<br />references with<br />heavy reuse</td>
<td>Multi-step, relational,<br />time-bound or rule-<br />bound questions</td>
</tr>
<tr>
<td>Main business<br />risk</td>
<td>Wrong or missing<br />answers when<br />retrieval misses</td>
<td>Stale or over-shared<br />content</td>
<td>High build and upkeep<br />cost; wrong links in the<br />graph</td>
</tr>
<tr>
<td>Typical owner</td>
<td>Platform or search<br />team</td>
<td>Platform team, with<br />content owners</td>
<td>Data and domain<br />teams together</td>
</tr>
</tbody></table>
<h2>3. A better mental model: selection, reuse and structure</h2>
<p>Instead of asking "RAG, CAG or KAG?", ask three independent questions of every request — what should be <em>selected</em>, what can be <em>reused</em>, and what must be <em>structured</em> — because a single answer can need all three.</p>
<h3>Three design axes</h3>
<table>
<thead>
<tr>
<th>Axis</th>
<th>The question it answers</th>
<th>Primary technique</th>
<th>Typical failure if<br />ignored</th>
</tr>
</thead>
<tbody><tr>
<td><strong>Selection</strong></td>
<td>Which information is<br />relevant_and authorized_<br />for this request?</td>
<td>Retrieval: keyword,<br />semantic, SQL, API,<br />graph lookup (RAG)</td>
<td>The model answers<br />from the wrong or<br />forbidden material</td>
</tr>
<tr>
<td><strong>Reuse</strong></td>
<td>Which work can be<br />shared across requests<br />without breaking<br />freshness, permissions<br />or model compatibility?</td>
<td>Caching: prompt/prefix<br />and KV caches (CAG)</td>
<td>Paying again and again<br />to re-read the same<br />handbook</td>
</tr>
<tr>
<td><strong>Structure</strong></td>
<td>Which entities,<br />relationships, time limits,<br />rules and calculations<br />must be explicit rather<br />than buried in prose?</td>
<td>Knowledge graphs,<br />logical forms,<br />deterministic operations<br />(KAG)</td>
<td>Plausible but wrong<br />joins, dates and<br />arithmetic</td>
</tr>
</tbody></table>
<p>Seen this way, hybrids are natural rather than exotic. A cached handbook does not stop the system retrieving a newly issued notice. A graph traversal does not stop it retrieving the supporting clause. A retrieval pipeline can still cache its stable instructions.</p>
<h3>Four kinds of enterprise information</h3>
<p>The three axes become concrete once you sort enterprise information by what it is. Most knowledge fits one of four categories, and each has a natural home:</p>
<table>
<thead>
<tr>
<th>Category</th>
<th>Examples</th>
<th>Preferred treatment</th>
</tr>
</thead>
<tbody><tr>
<td><strong>Unstructured</strong><br /><strong>evidence</strong></td>
<td>Contracts, policies, manuals,<br />tickets, reports</td>
<td>Retrieval (RAG), including<br />multimodal retrieval for<br />drawings and scanned pages</td>
</tr>
<tr>
<td><strong>Stable shared context</strong></td>
<td>System instructions, approved<br />reference sets, a product<br />handbook</td>
<td>Prefix caching, or bounded-<br />corpus CAG where it tests well</td>
</tr>
<tr>
<td><strong>Relational knowledge</strong></td>
<td>Suppliers and the parts they<br />supply, asset hierarchies,<br />dependencies, ownership</td>
<td>Graph queries (GraphRAG /<br />KAG) or relational joins</td>
</tr>
<tr>
<td><strong>Authoritative operational state</strong></td>
<td>Inventory, balances, open orders, production events, credit limits</td>
<td>Governed APIs, SQL and semantic-layer queries against the system of record</td>
</tr>
</tbody></table>
<p>The fourth category is the one most often mishandled. A vector index or a knowledge graph should never become an accidental copy of transactional data: the copy goes stale within minutes, and it bypasses the authorization rules of the system that owns the data.</p>
<h2>Part II — How each approach works</h2>
<h2>4. Inside RAG: dynamic evidence selection</h2>
<p>RAG is the enterprise default for grounding models in large, changing, permissioned knowledge. In my experience its quality is set far more by retrieval engineering (how documents are parsed, chunked, searched and reranked) than by the choice of vector database, which is where too many programs spend their first procurement cycle.</p>
<h3>The pipeline at a glance</h3>
<p>Every RAG system has two halves. An <strong>offline half</strong> prepares the library: it parses documents, splits them into chunks, converts each chunk into numbers that capture its meaning (embeddings) and stores them in search indexes. An <strong>online half</strong> answers questions: it searches those indexes, picks the best evidence, and asks the model to answer from it.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/a2a2b588-1af4-4012-9703-876be7f0ad18.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 3 · RAG reference pipeline: offline ingestion and online serving</em></p>
<p>The top lane runs whenever documents change; the bottom lane runs for every question and snakes from the question to a cited answer. The dashed line is the only link between them: the search step looks up the indexes the offline lane built.</p>
<h3>The four levers that move quality</h3>
<p>The best public evidence that chunk context, hybrid search and reranking compound comes from Anthropic's 2024 contextual retrieval study. Adding chunk context, then keyword search, then reranking each reduced how often the right passage went missing, and together they cut those failures by roughly two thirds. The one-off cost of adding context was trivial with prompt caching. These were the vendor's own datasets, so test on yours, but the direction matches what I see in client pipelines: <strong>most RAG quality problems are retrieval problems, and they are cheap to fix.</strong></p>
<h2>5. Inside CAG: reusing a stable knowledge prefix</h2>
<p>I treat CAG as a deployment pattern rather than an architecture: if a small, stable body of knowledge is going into the prompt anyway, compute the model's reading of it once and reuse it. Every major model vendor now offers this as a managed feature. Its practical ceiling is set by how much context a model can actually use well, not by the window size on the datasheet.</p>
<h3>How CAG works</h3>
<p>The pattern was named in a 2024 paper with the deliberately provocative title "Don't Do RAG: When Cache-Augmented Generation is All You Need for Knowledge Tasks" (Chan et al.). It describes three phases:</p>
<ol>
<li><strong>Preload.</strong> Fit the whole document collection into the context window, run the prefill once, and store the KV cache.</li>
<li><strong>Infer.</strong> For each question, load the cache, append the question, and generate. No retrieval runs.</li>
<li><strong>Reset.</strong> Truncate the question tokens from the cache so it returns to the clean knowledge state.</li>
</ol>
<ul>
<li>"Reset" only clears the last question. <strong>It does nothing about corpus updates</strong>: any change to the knowledge means recomputing the cache.</li>
</ul>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/23be279e-f9b9-4043-b3fe-b945e7391191.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 4 · CAG reference flow: preload once, serve many</em></p>
<p>The top lane is paid once per corpus version; the bottom lane runs per question. The loop on the right is the reset that returns the cache to its clean state. The only way new knowledge enters is to rebuild the top lane.</p>
<h3>What the original study really shows</h3>
<p>The study is widely quoted and rarely read. It used one small open model, small corpora and a soft similarity metric. CAG edged out RAG on most of the small tests by very thin margins, and lost on the largest corpus, the one closest to a real knowledge base. The authors themselves call CAG impractical for significantly larger datasets.</p>
<p>The famous "40x faster" compares CAG with re-reading the whole corpus on every question, not with RAG. A simple keyword RAG pipeline was faster than CAG at every size tested, and CAG's response time grows with the corpus while RAG's stays flat. <strong>What the paper proves is that if a small corpus goes into the prompt, it should be cached. It does not prove that caching beats retrieval at enterprise scale.</strong></p>
<h3>Where CAG fits</h3>
<p>My guidance: consider bounded-corpus CAG when the authorized content fits comfortably within the context the model uses well, leaves room for the question, history and answer, and holds up on quality, latency and cost in a side-by-side test against tuned RAG. Good candidates change rarely, are queried heavily, and need no per-user permissions inside the corpus: HR and benefits handbooks, product FAQs, support playbooks, standard operating procedures, a single contract or regulation, and agent system prompts with tool documentation. Poor fits are large or fast-changing catalogues, multi-tenant document sets, permissioned content, and audit regimes that require citing the exact passage used.</p>
<h2>6. Inside KAG: structured knowledge and executable reasoning</h2>
<p>Graph methods pay off on questions that chain entities, depend on dates, apply rules or need a view across a whole portfolio, and they lose to plain RAG on simple lookups. For a technology leader the more important point is that <em>which</em> graph method you choose matters more than whether you use a graph at all: the cost of answering a question varies by orders of magnitude across methods.</p>
<h3>Why similarity search is not enough</h3>
<p>Consider: <em>"Which supplier-related events contributed to production losses at Plant A last quarter, and which purchase orders were affected?"</em> Answering it means connecting a supplier → a delivered component → an equipment asset → a maintenance order → a production interruption → a financial impact → purchase orders. Those links live across</p>
<p>SAP, maintenance records, contracts and incident reports. A vector retriever finds documents that <em>sound</em> related; it does not establish the relationships between the underlying business entities. That gap is what KAG targets.</p>
<h3>The KAG framework (Ant Group / OpenSPG)</h3>
<p><strong>KAG</strong> comes from Ant Group, which published it in 2024 and open-sourced it as OpenSPG/KAG. It targets two RAG weaknesses: the <strong>gap between "sounds similar" and "is relevant"</strong>, and blindness to <strong>"knowledge logic"</strong> such as numbers, time relations and expert rules. It combines a domain schema, two-way links between graph and source text, and a planner that turns each question into executable steps.</p>
<p>In short: <strong>KAG is GraphRAG plus a symbolic planner-executor plus a domain schema.</strong> Its distinctive contribution is the logical form — an auditable, step-by-step plan that can include arithmetic and deduction.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/9f819d84-3730-4bc3-b54f-a54dee2f4253.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 5 · KAG reference flow: builder and solver</em></p>
<p>The builder runs offline and keeps the graph and the text chunks linked both ways. The solver turns each question into a plan, executes it against graph, text and tools, and loops back to re-plan when evidence is missing.</p>
<h3>What the KAG results mean for an enterprise</h3>
<p>On academic multi-hop benchmarks KAG posted the largest gains of any graph method, though those figures come from its authors and are often quoted wrongly. The more persuasive evidence is from Ant Group's own production use: in government-services Q&amp;A, precision rose from roughly two thirds with naive RAG to above 90%, with similar improvements in health-insurance policy questions. The authors are candid about the cost: many model calls to build the graph and to plan each answer, planning that roughly doubles output, slow entity standardization, and unresolved extraction consistency. <strong>KAG buys precision on rule-bound domains with engineering effort; it is not a free upgrade.</strong></p>
<p><strong>The open-source framework is maturing.</strong> Recent releases cut graph-construction cost substantially and added MCP support, which positions KAG as a knowledge service that agents can call rather than a standalone application. Domain variants are appearing in areas such as building-engineering standards, which is exactly where I expect KAG to earn its keep: dense, rule-heavy reference material where a wrong clause is expensive.</p>
<h3>Independent evidence: graphs help on relations, hurt on lookups</h3>
<p>Two independent studies published in 2025 and 2026 compared graph methods with plain RAG on the same questions. Their findings line up, and they are what I use to set expectations with business sponsors:</p>
<table>
<thead>
<tr>
<th>Question type</th>
<th>Better choice</th>
</tr>
</thead>
<tbody><tr>
<td>Simple fact lookup</td>
<td>Plain RAG, slightly</td>
</tr>
<tr>
<td>Detail questions on a long document</td>
<td>Plain RAG, clearly</td>
</tr>
<tr>
<td>Multi-hop questions</td>
<td>Graph methods, slightly</td>
</tr>
<tr>
<td>Time-dependent questions</td>
<td>Graph methods, by a wide margin</td>
</tr>
<tr>
<td>Themes and summaries across a<br />corpus</td>
<td>Graph methods, clearly</td>
</tr>
<tr>
<td>Questions with no answer in the data</td>
<td>Plain RAG: graph methods often answer anyway<br />instead of abstaining</td>
</tr>
</tbody></table>
<p>Three details matter for planning. Automatically built graphs captured only around two thirds of the entities needed to answer the questions. Each approach answered a meaningful set of questions the other missed, and combining both beat either alone. And model-based judges flipped their verdicts when two answers swapped position, which undermines many published "win rate" claims. <strong>The case for graphs is real but narrow, and it is strongest in a hybrid.</strong></p>
<h2>Part III — Comparing and combining</h2>
<h2>7. Head to head: what the evidence means for your architecture</h2>
<p>No approach wins everywhere, and nobody has yet compared all three on the same data. What the independent studies do agree on is enough to decide: good retrieval matches long-context prompting at a fraction of the tokens, graphs win on multi-step, time-based and summary questions but lose on simple lookups, and combining approaches beats any single one. For a CTO, the more important differences are in cost.</p>
<h3>Token usage: where the tokens go, and how to govern them</h3>
<p>When I review the bill for a production assistant, the spend is rarely where the team expects. It is driven less by the answer than by everything sent alongside the question: instructions, conversation history, retrieved evidence, cached content, tool results and, in agentic systems, every intermediate step. Each approach shapes that mix differently.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/dfb48750-296a-4cc9-9833-bc36156c5f5d.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 6 · where the tokens go in one request, by approach (illustrative)</em></p>
<p>The numbers are illustrative, not measured, but the shapes are typical. RAG keeps each request small by sending only a few reranked passages. CAG sends the whole corpus every time; caching makes that affordable, but only while the cache stays warm and the corpus stays small. Graph approaches add planning calls and intermediate results. Agents are the real multiplier: each step re-sends the instructions and the growing context, so cost grows much faster than the number of steps unless context is pruned between them.</p>
<table>
<thead>
<tr>
<th>Token component</th>
<th>What drives it</th>
<th>How to control it</th>
</tr>
</thead>
<tbody><tr>
<td>Instructions and tool<br />definitions</td>
<td>Prompt length; agents carrying<br />every tool's schema on every<br />call</td>
<td>Cache them; give each route<br />only the tools it needs; load<br />tool definitions just in time</td>
</tr>
<tr>
<td>Conversation history</td>
<td>Long sessions replayed in full</td>
<td>Summarize or truncate; keep<br />durable facts in a memory<br />store, not the transcript</td>
</tr>
<tr>
<td>Retrieved evidence<br />(RAG)</td>
<td>Number and size of passages</td>
<td>Rerank to fewer, better<br />passages; adapt how many to<br />the question; compress</td>
</tr>
<tr>
<td>Cached prefix (CAG)</td>
<td>Corpus size times question<br />volume</td>
<td>Billed at the cached-read rate;<br />watch rewrites on expiry; keep<br />volatile content out of the<br />prefix</td>
</tr>
<tr>
<td>Graph results and plans<br />(KAG)</td>
<td>Traversal breadth, community<br />summaries, planning steps</td>
<td>Prefer local over global search;<br />cap hops; return paths and<br />IDs, not whole documents</td>
</tr>
<tr>
<td>Tool outputs and<br />intermediate steps</td>
<td>Agent iterations; verbose tool<br />responses</td>
<td>Step and token budgets per<br />request; trimmed, structured<br />tool outputs</td>
</tr>
<tr>
<td>Reasoning tokens</td>
<td>Model "thinking" settings</td>
<td>Set reasoning effort per route;<br />reserve deep reasoning for<br />hard question classes</td>
</tr>
<tr>
<td>Output</td>
<td>Answer length and format</td>
<td>A clear answer contract;<br />concise formats; cite by<br />source ID</td>
</tr>
</tbody></table>
<p><strong>Treat tokens as a managed resource, not a by-product.</strong> In practice that means:</p>
<ul>
<li><strong>Budgets.</strong> Set a token budget per use case and a hard cap per request, enforced by the orchestrator, with a defined behaviour when it runs out (answer what is supported, list the gaps).</li>
<li><strong>Routing to the right model.</strong> Send simple, well-grounded questions to smaller, cheaper models and reserve frontier models for the question classes that need them. Output tokens typically cost several times more than input tokens, so verbose answers and heavy reasoning are disproportionately expensive.</li>
<li><strong>Metrics.</strong> Track input versus output tokens, cache hit rate, tokens per request and per correct answer, and steps per agent task, by use case. Alert on runaway agent loops.</li>
<li><strong>Showback.</strong> Report token spend by business unit and use case next to the value it produced. Cost per correct, authorized answer is the number that keeps the conversation with the CFO grounded.</li>
</ul>
<h2>8. Combining them: hybrid architecture and context engineering</h2>
<p>The research groups behind all three approaches have each moved towards hybrids, and the 2026 practice of <em>context engineering</em> treats RAG, CAG and KAG as complementary services that an orchestrator combines to assemble the smallest sufficient evidence for each step. This is where I would point any enterprise architecture.</p>
<h3>How the semantic layer should operate</h3>
<p>Most programs I review treat the semantic layer as a BI artefact. In an AI architecture it is something more important: <strong>the contract between the business's numbers and the model.</strong> The model never calculates a governed metric itself and never queries raw tables. It asks the semantic layer, which returns the number together with its definition and provenance.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/2c95bb68-ba40-47a3-a34e-d66f6c1c91ec.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 7 · how a governed semantic layer answers a numeric question for an AI assistant</em></p>
<p>The model's job is limited to steps 1, 2 and 7: understanding the question, mapping it to a governed metric, and explaining the result. Everything that must be exact (joins, formulas, currency conversion, fiscal calendars, access rules) happens deterministically inside the layer. That division is what makes numeric answers auditable.</p>
<p>The operating principles I recommend:</p>
<ul>
<li><strong>One definition per metric, owned and versioned.</strong> "Downtime cost", "on-time delivery" and "active customer" each have a named business owner, a written definition and a version. When the definition changes, old versions stay queryable for audit.</li>
<li><strong>Expose a service, not a schema.</strong> Publish metrics through a governed API or MCP tool with typed parameters (metric, entity, period, filters). The model fills in the parameters; the layer writes the query. Free-form SQL generated against raw ERP tables is the single most common source of confidently wrong numbers.</li>
<li><strong>Enforce access under the user's identity, inside the query.</strong> Row- and column-level rules come from the same policy engine as the rest of the platform, so a user sees the same numbers in the assistant as in their reports, and no more.</li>
<li><strong>Return metadata with every number.</strong> Definition version, as-of timestamp, source system and the query used travel with the result, and the answer cites them.</li>
<li><strong>Declare freshness per metric.</strong> Some numbers are read live from the ERP, others refresh hourly or daily from the warehouse. The answer should say which.</li>
<li><strong>Share identities with the graph.</strong> The semantic layer and the knowledge graph use the same entity and master-data IDs. The graph answers "which suppliers affect plant 1000"; the semantic layer answers "what that cost"; the IDs make the two answers line up.</li>
<li><strong>Separate certified from exploratory.</strong> Only certified metrics may feed answers that go to customers, regulators or the board. Exploratory queries are allowed but clearly labelled.</li>
<li><strong>Put metric changes through the release gate.</strong> Definition changes re-run the evaluation set, including a check that natural-language questions still resolve to the right metric.</li>
<li><strong>Cache results safely.</strong> Key cached results by metric version, user scope and as-of time, and invalidate them on data refresh.</li>
</ul>
<table>
<thead>
<tr>
<th>Responsibility</th>
<th>Owner</th>
</tr>
</thead>
<tbody><tr>
<td>Metric definitions and certification</td>
<td>Business data owners, typically finance and<br />operations</td>
</tr>
<tr>
<td>Semantic model, API and MCP tooling</td>
<td>Data platform team</td>
</tr>
<tr>
<td>Access policies</td>
<td>Security and data governance</td>
</tr>
<tr>
<td>Question-to-metric resolution quality</td>
<td>AI platform team, through the evaluation set</td>
</tr>
</tbody></table>
<p><strong>In SAP landscapes much of this layer already exists.</strong> CDS views and the virtual data model in S/4HANA, and the analytical models in SAP Datasphere and Business Data Cloud, carry SAP's business semantics and authorizations. AI should consume these rather than rebuild definitions. Where a metric spans SAP and non-SAP systems, define it once in the enterprise semantic layer and expose it to agents as a governed tool.</p>
<p>Reference architecture: a four-tier enterprise knowledge platform</p>
<p>This is the target architecture I recommend: a cached core, hybrid retrieval, a selective graph layer and a semantic layer, with a router in front and governance across every path. It is not a vendor standard. Its main advantage is that it <strong>turns an irreversible architecture bet into a reversible routing decision.</strong></p>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/6c16a0ac-6149-4691-86db-5743683865ae.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 8 · four-tier enterprise knowledge platform</em></p>
<h2>9. Decision framework</h2>
<p>My default for every new use case: start with a hybrid retrieval baseline unless the whole corpus is small, stable and shared. Then add a cached core, a graph layer and a router only when the workload proves each one pays for itself. This keeps early investment small and makes every later addition a measured decision rather than a bet.</p>
<h3>The decision tree</h3>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/18ed2d93-dc78-4f2b-b242-c9550f72f9df.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 9 · decision tree, from use case to architecture</em></p>
<p>Only the first question can end the tree early. After the retrieval baseline, each "yes" adds a layer and the flow continues, so a mature system often ends up with all four tiers of Section 8, each justified by its own evidence.</p>
<p>Recommended starting routes for the router: stable handbook questions use the cached core; anything mentioning recent amendments or dates uses retrieval; exact numeric aggregation calls deterministic computation (SQL or a calculator), never the model's arithmetic; entity-chain questions use the graph; corpus-wide "themes" questions use summaries or GraphRAG-style global search; weak evidence triggers a targeted search or an honest "insufficient evidence" — not unlimited autonomous retries.</p>
<h2>Part IV — Running it in the enterprise</h2>
<h2>10. Security, governance and trust</h2>
<p>In my experience, the failures that reach the board are rarely about model capability or retrieval accuracy. They come from weak access control, poisoned or stale sources, and uncontrolled agent actions, and each architecture fails in its own way. This is the section I would ask every CISO and data-protection officer to read.</p>
<h3>Rule one: authorize before knowledge reaches the model</h3>
<p>If an employee may read a plant's maintenance records but not confidential supplier pricing, the pricing must never enter that employee's model context. <strong>Filtering the final answer is not enough; unauthorized data must not be supplied in the first place.</strong> The same applies to relationships: a user allowed to see two entities is not automatically allowed to discover a confidential relationship between them, and a derived relationship or summary can reveal what no single visible document does.</p>
<p>This is where the three architectures differ most:</p>
<ul>
<li><strong>RAG and graph retrieval</strong> can filter by permission at query time, so each user's context holds only what they are entitled to see.</li>
<li><strong>CAG preloads the whole corpus</strong>, so every user of a cache sees all of it. It suits only content everyone may see, or needs <strong>a separate cache per access tier</strong> — multiplying write costs and memory.</li>
<li><strong>Graphs</strong> must propagate permissions from source chunks to the entities, edges and community summaries derived from them.</li>
</ul>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/335ee7a8-1239-4437-a9b9-181593903809.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 10 · three enforcement stages, one policy decision point</em></p>
<p>Stage 1 is where RAG, CAG and KAG differ most. Retrieval can filter per user inside the search. A graph has to filter nodes, edges and any summaries built from them. A cache cannot be filtered at all once it is built, so the only option is a separate cache per access tier.</p>
<h3>Deletion and revocation must reach every derived artifact</h3>
<p>When a document is deleted or a user loses access, the change has to propagate to everything built from it: index entries, embeddings, cached retrieval results, KV caches and prefix caches that contain it, graph nodes and edges extracted from it, and community summaries that mention it. Rebuilding all of that takes time, so the order matters. Serving policy changes first and immediately, so requests stop using the revoked knowledge even while the rebuild runs:</p>
<ol>
<li><strong>Access change recorded</strong> (deletion, revocation, legal hold release)</li>
<li><strong>Serving-policy denial</strong> takes effect at once for the affected scope</li>
<li><strong>Affected artifacts retired</strong> from serving: index entries, caches, graph elements and summaries are marked unusable</li>
<li><strong>Rebuild</strong> the affected index segments, caches and graph regions</li>
<li><strong>Validate</strong> that the rebuilt artifacts no longer contain the removed content</li>
<li><strong>Publish</strong> a new, version-consistent manifest across index, cache and graph</li>
</ol>
<p>The gap between steps 2 and 6 is where most leakage happens in practice, which is why revocation propagation time belongs on the evaluation dashboard (Section 11).</p>
<h2>11. Evaluation and benchmarking</h2>
<p>Compare workloads, not labels. An architecture that wins on an academic benchmark may lose on your SAP maintenance data, and a cache that cuts response time may not improve a single answer. Every organization needs its own evaluation set, run the same way across every option. I treat this as the single most important investment in the program, because it is what lets every later decision be made on evidence.</p>
<h3>A minimum viable evaluation for the first 15 days</h3>
<p>Teams often postpone evaluation until it is too late to change the architecture. This is a starting kit that fits inside the first phase of the roadmap:</p>
<table>
<thead>
<tr>
<th>Element</th>
<th>Minimum setup</th>
</tr>
</thead>
<tbody><tr>
<td>Question set</td>
<td>200–300 questions reviewed by a domain expert,<br />with about a quarter held back for final testing</td>
</tr>
<tr>
<td>Question mix (starting point)</td>
<td>About 30% single-hop factual, 20% multi-hop, 10%<br />time-based, 10% numeric or rule-based, 10%<br />summary, 10% unanswerable (should abstain), 10%<br />permission-boundary cases</td>
</tr>
<tr>
<td>Core quality metrics</td>
<td>Groundedness, answer relevance, citation<br />precision, correct abstention</td>
</tr>
<tr>
<td>Core operational metrics</td>
<td>p95 latency; cost per correct, authorized answer</td>
</tr>
<tr>
<td>Diagnostic</td>
<td>An oracle-evidence test: give the model hand-<br />picked evidence to separate retrieval failures from<br />generation failures</td>
</tr>
<tr>
<td>Judging</td>
<td>A model as judge with randomized answer order,<br />plus a human-reviewed sample, because judges<br />favour position and length</td>
</tr>
<tr>
<td>Statistics</td>
<td>Paired comparisons on the same questions, with<br />confidence intervals, reported per question class</td>
</tr>
<tr>
<td>Regression gate</td>
<td>Every change to prompts, models, chunking,<br />indexes, caches or graphs re-runs the set; a drop<br />beyond an agreed margin blocks release</td>
</tr>
</tbody></table>
<p>Add adversarial tests early: injected instructions inside documents, poisoned nearduplicates, questions that try to elicit restricted relationships, and stale-version traps.</p>
<h2>12. Industry use cases</h2>
<p>Asset-intensive and regulated industries get the most from combining all three approaches, because they already keep an implicit ontology (asset registers, product hierarchies, policy rules) and ask genuinely multi-hop questions — but the authoritative numbers must always come from systems of record, not from the graph or the model.</p>
<h3>Architecture by industry at a glance</h3>
<table>
<thead>
<tr>
<th>Industry</th>
<th>CAG (cached<br />core)</th>
<th>RAG (hybrid<br />retrieval)</th>
<th>KAG / GraphRAG<br />(graph layer)</th>
<th>Where I would<br />start</th>
</tr>
</thead>
<tbody><tr>
<td>Energy / oil &amp;<br />gas</td>
<td>HSE<br />procedures,<br />permit-to-<br />work rules,<br />SOPs</td>
<td>Well reports,<br />drilling and<br />maintenance<br />logs,<br />engineering<br />documents<br />(often visually<br />rich)</td>
<td>Field, facility,<br />equipment and<br />component<br />hierarchies;<br />failure modes;<br />procedure links</td>
<td>Multimodal<br />RAG over<br />engineering<br />documents,<br />then an asset<br />graph</td>
</tr>
<tr>
<td>Manufacturing</td>
<td>Product-line<br />FAQs, safety<br />procedures</td>
<td>Manuals,<br />service<br />bulletins</td>
<td>Bill-of-materials<br />and asset/failure<br />graphs</td>
<td>RAG for<br />service, graph<br />for root-cause<br />and supplier<br />impact</td>
</tr>
<tr>
<td>Healthcare / life<br />sciences</td>
<td>Clinical<br />protocols,<br />formularies,<br />benefit<br />summaries</td>
<td>Literature,<br />payer policies,<br />clinical notes<br />(strict access<br />control)</td>
<td>Drug–gene–<br />disease graphs,<br />claim-to-policy<br />relationships</td>
<td>Permission-<br />aware RAG;<br />KAG for payer-<br />policy rules</td>
</tr>
<tr>
<td>Financial<br />services /<br />insurance</td>
<td>Product and<br />policy FAQs</td>
<td>Research,<br />filings,<br />contracts</td>
<td>KYC/AML entity<br />networks, riders<br />and exclusions,<br />regulatory<br />lineage</td>
<td>RAG for<br />research; graph<br />for entity risk<br />and policy<br />rules</td>
</tr>
<tr>
<td>Public sector</td>
<td>Citizen-<br />service FAQs</td>
<td>Permission-<br />aware search<br />with data<br />residency</td>
<td>Rule-bound<br />eligibility</td>
<td>Cached FAQs<br />plus rules-<br />driven<br />eligibility</td>
</tr>
<tr>
<td>Legal</td>
<td>One contract<br />or regulation<br />under review</td>
<td>Contract and<br />clause search</td>
<td>Clause and<br />precedent<br />citation graphs</td>
<td>RAG with<br />exact-passage<br />citation</td>
</tr>
<tr>
<td>Retail /<br />customer<br />support</td>
<td>Returns,<br />warranty and<br />shipping<br />policies</td>
<td>Orders,<br />products and<br />inventory via<br />retrieval and<br />live tools</td>
<td>Supplier and part<br />networks</td>
<td>Cached<br />policies plus<br />live order<br />lookup</td>
</tr>
<tr>
<td>IT operations /<br />cybersecurity</td>
<td>Runbooks</td>
<td>Logs and<br />tickets (just-in-<br />time search<br />suits logs)</td>
<td>Configuration-<br />item, change and<br />incident<br />dependency<br />graphs</td>
<td>Cached<br />runbooks plus<br />a dependency<br />graph</td>
</tr>
</tbody></table>
<h3>SAP and ERP landscapes</h3>
<p>ERP systems are the clearest case for combining all three approaches, because they hold <strong>transactional truth that changes by the minute, business semantics encoded in the data model, and fine-grained authorizations</strong> — none of which a vector index or a cached prefix can safely replace. The rule of thumb for SAP landscapes: <strong>documents go to RAG, stable reference goes to the cached core, relationships go to the graph, and live facts come from SAP itself.</strong></p>
<h3>SAP's own building blocks map onto the three approaches</h3>
<p>SAP's AI stack now contains a native counterpart for each layer (status as of November 2026; check exact availability for your edition and region):</p>
<table>
<thead>
<tr>
<th>Approach</th>
<th>SAP building block</th>
<th>What it does</th>
</tr>
</thead>
<tbody><tr>
<td>RAG</td>
<td>SAP HANA Cloud vector engine<br />and document grounding in the<br />generative AI hub and Joule</td>
<td>Generally available since 2024; the<br />document-grounding module<br />implements RAG on top of it</td>
</tr>
<tr>
<td>KAG / graph</td>
<td>SAP HANA Cloud knowledge graph<br />engine and SAP Knowledge Graph</td>
<td>Generally available since 2025; SAP<br />positions SAP Knowledge Graph as<br />the semantic bridge between Joule<br />agents and business data and<br />processes</td>
</tr>
<tr>
<td>Unified data</td>
<td>SAP Business Data Cloud (with<br />Databricks)</td>
<td>The trusted data layer that grounds<br />Joule agents across SAP and non-<br />SAP sources</td>
</tr>
<tr>
<td>Agents and<br />routing</td>
<td>Joule, Joule Agents and Joule<br />Studio</td>
<td>Custom agents grounded on<br />business documents and data, with<br />MCP and agent-to-agent<br />collaboration, and governed<br />execution of multi-step and third-<br />party agents</td>
</tr>
<tr>
<td>CAG</td>
<td>No SAP-branded equivalent</td>
<td>Prompt caching depends on the<br />model provider reached through<br />the generative AI hub; confirm<br />support and pricing per model</td>
</tr>
</tbody></table>
<p>For an SAP-centric client the practical question is therefore not <em>whether</em> to use RAG, CAG or KAG, but <strong>when to use SAP's native layer versus an external stack</strong> — typically SAPnative where the knowledge and the users live inside SAP and Joule, and an external hybrid platform where knowledge spans SAP, other ERPs, document systems and nonSAP applications, connected to SAP agents through MCP or A2A.</p>
<h2>13. Implementation roadmap</h2>
<p>A 90-day pilot can prove or disprove each layer in order — retrieval baseline first, then caching, then a graph, then routing — with a go/no-go decision based on targets agreed in advance by accountable owners.</p>
<h3>The 90-day plan</h3>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/9a013aab-0b17-4965-83f4-678d825d5734.jpg" alt="" style="display:block;margin:0 auto" />

<p><em>Figure 11 · 90-day pilot roadmap: six phases, one gate</em></p>
<p>Phases are shown at equal width, not to scale. The coloured phases test RAG, CAG and KAG in the same colours used throughout the paper.</p>
<p>Investment is usually decided at two points: after phase 2 (is the baseline good enough to build on?) and at the end (scale, extend or stop). Business KPIs agreed in phase 1, such as time saved per case, escalation rate or cost per resolved request, should be reported at both.</p>
<p>This is a pilot sequence. Enterprise-wide rollout, regulated-domain validation and legacy integration usually take longer.</p>
<h2>14. Outlook and recommendations</h2>
<p>"RAG vs CAG vs KAG" is a false choice: the durable asset is a governed, evaluated knowledge platform that places each question on the cheapest path that answers it correctly, and that survives the next change of model or retrieval technique.</p>
<h3>Closing</h3>
<p>RAG established that models do not need to hold all knowledge in their weights. CAG showed that knowledge preparation and repeated inference can be optimized. KAG moved the focus to relationships, logic and domain reasoning. None of them alone solves data quality, authorization, business semantics, freshness, provenance, cost or agent governance. The question for the next generation of enterprise AI is not how much a model can retrieve or remember, but this: <strong>can the system access the right knowledge, understand its business meaning, verify its validity, respect its boundaries, and use it to produce a trustworthy outcome?</strong></p>
<p>If I were starting this program on Monday, I would do three things in the first month: commission a question-mix analysis of what users actually ask, stand up a small evaluation set owned jointly by the business and the platform team, and fix the retrieval basics in whatever RAG system is already running. Everything else in this article (caching, graphs, routing, agents) becomes a decision you can make on evidence once those three are in place.</p>
<h2>How Elixir Global puts this into practice</h2>
<p>Everything in this article comes out of the work we do with clients at Elixir Global, an AI-first enterprise consulting firm headquartered in Atlanta, with offices in Houston, Dubai, Bengaluru and Singapore. Together with our subsidiaries S2 Integrators (SAP delivery) and Kyyte (procurement and SAP), we spend most of our time where this article lives: at the point where AI meets the systems of record that run the business.</p>
<p>Our approach follows the same order this article recommends. We start with the questions people actually ask and an evaluation set the business owns. We fix retrieval before adding anything new, put a governed semantic layer in front of SAP and other ERPs so numbers are never improvised, and add caching, graphs and routing only where the evidence says they pay.</p>
<p><strong>AgentVault</strong> is where that thinking becomes reusable. AgentVault™ is our proprietary library of more than 500 enterprise agents, covering supply chain, procurement, finance and document-heavy processes such as IDoc handling and invoice OCR. The agents are designed to sit on top of a governed knowledge platform rather than carry their own copies of enterprise data: they retrieve documents, read live values through governed services, and call graph and semantic-layer tools over MCP. They integrate with SAP Joule, and because they are built on open components, clients can adopt the latest models without vendor lock-in or dependence on any single platform roadmap.</p>
<p>Governance is built in, not bolted on. AgentVault agents follow the same guardrails described in Section 10, including SOX and FedRAMP controls where they apply, and our BYOAI-Gov™ framework and GRC tooling help clients find governance gaps early, before they reach production. We have deployed agents and set up AI governance in federal, oil and gas, manufacturing, life sciences, utilities and consumer goods environments, and we work alongside SAP, Tricentis and Anthropic as a Claude Partner Network member.</p>
<h2>Further reading</h2>
<ul>
<li><strong>Download the full whitepaper (PDF):</strong> <a href="https://doi.org/10.5281/zenodo.24399422">RAG, CAG and KAG: Choosing How Enterprise AI Uses What the Business Knows</a> (Zenodo, DOI 10.5281/zenodo.24399422)</li>
<li><strong>Related white paper:</strong> <a href="https://doi.org/10.5281/zenodo.24386748">The Token Economy: How Smarter AI Computation Will Reshape Enterprise Costs and Value</a> (DOI 10.5281/zenodo.24386748)</li>
<li><strong>Related white paper:</strong> <a href="https://doi.org/10.5281/zenodo.24378767">Governing Rogue AI Agents with Valid Credentials</a> (DOI 10.5281/zenodo.24378767)</li>
</ul>
<h2>About the author</h2>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/eea4ee89-0c5f-43d8-87bd-69943553809b.jpg" alt="" style="display:block;margin:0 auto" />

<p><strong>Ganesh Raju</strong> is Chief AI &amp; Innovation Officer (CAIO) and CTO at <a href="https://www.elixirglobal.com">Elixir Global</a>, an AI-first enterprise consulting firm headquartered in Atlanta with offices in Houston, Dubai, Bengaluru and Singapore. He leads enterprise AI strategy and <strong>AgentVault</strong>, Elixir's portfolio of governed, production-ready AI agents for SAP and enterprise operations, and the Migra AI-native data migration platform.</p>
<p>He brings more than 15 years of experience in artificial intelligence, machine learning and data engineering. As Head of Big Data, Data Science &amp; AI at Linaro he led Arm enablement of the open-source big data and data science ecosystem, served as ODPi PMC member and TSC lead and as a Linux Foundation TSC member, and led the Apache Bigtop community. An open-source committer, he has contributed to TensorFlow, Apache Spark and Hadoop.</p>
<p>He is the author of <em>AI Blockchain Design and Deployment</em> (BPB Publishing), founder and CEO of <a href="http://Akshaya.io">Akshaya.io</a>, founder of RapidEVChargE (rapidevcharge.com), an investor, an advisor to Canon, and a mentor to founders and technology leaders. He is a former Vice Chair of IEEE Houston and a participant in the Wharton Executive Education Chief Technology Officer program. He is based in Houston, Texas.</p>
<p><em>Connect on</em> <a href="https://www.linkedin.com/in/ganeshraju07"><em>LinkedIn</em></a> <em>·</em> <a href="https://github.com/ganeshraju"><em>GitHub</em></a> <em>·</em> <a href="https://ganeshraju.hashnode.dev"><em>Blog</em></a></p>
<p><em>Views are the author's own. Elixir Global offers products and services related to the subject of this paper. Research results cited are from published studies; figures marked illustrative are not measurements.</em></p>
<p>#RAG #CAG #KAG #EnterpriseAI #AgenticAI #KnowledgeGraphs #AIArchitecture #AIGovernance #GenerativeAI #CAIO #CTO #SAP</p>
]]></content:encoded></item><item><title><![CDATA[The Token Economy: How Smarter AI Computation Will Reshape Enterprise Costs and Value]]></title><description><![CDATA[How caching, retrieval, routing, verification and selective reading cut enterprise AI cost per completed task 62-69%, and the control layer CTOs need.]]></description><link>https://ganeshraju.hashnode.dev/the-token-economy-how-smarter-ai-computation-will-reshape-enterprise-costs-and-value</link><guid isPermaLink="true">https://ganeshraju.hashnode.dev/the-token-economy-how-smarter-ai-computation-will-reshape-enterprise-costs-and-value</guid><category><![CDATA[AI]]></category><category><![CDATA[llm]]></category><category><![CDATA["CAIO"]]></category><category><![CDATA[token]]></category><category><![CDATA[#ArtificialIntelligence ]]></category><category><![CDATA[Machine Learning]]></category><dc:creator><![CDATA[Ganesh Raju]]></dc:creator><pubDate>Fri, 20 Nov 2026 04:36:40 GMT</pubDate><content:encoded><![CDATA[<p><em>A forward-looking whitepaper for business and technology leaders. Full PDF with all appendices:</em> <a href="https://doi.org/10.5281/zenodo.24386748"><em>DOI 10.5281/zenodo.24386748</em></a><em>.</em></p>
<h2>Executive decision brief</h2>
<h3>The next AI breakthrough may be learning what not to compute</h3>
<p>For several years, AI progress has come from scale: larger models, longer context windows and more GPUs. That has changed what machines can do. It has also created an uncomfortable economic reality. As AI moves from assistants to agents that read, plan, act and check their own work, the computation behind a single business task can grow sharply. A token gets cheaper, but finishing the task can still take many more of them.</p>
<p>Enterprise AI efficiency is not simply a matter of buying cheaper tokens. It is a matter of allocating computation to the evidence, generation and verification a business task actually needs. This paper argues that enterprises need a control layer that allocates computation according to risk and business value. That layer, not any single model or research technique, is the durable investment.</p>
<h3>Fewer billed tokens, or less computation per token?</h3>
<p>The next wave of AI efficiency will not necessarily come from consuming fewer billed tokens. It may come from doing less computation on those tokens. New research on selective reading lets a model read every input token lightly and give deep processing only to the tokens that matter. The prompt still contains every token. So a company paying a conventional API price per input token will not automatically see a smaller invoice. A company running its own models can turn the same efficiency into more capacity from the same GPUs. Whether the savings ultimately reach customers will depend as much on commercial pricing as on technology.</p>
<h3>What is demonstrated, what is available, what is projected</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/7291cbb4-6fa3-40dd-b0b2-ff08ba364ce8_1600x737.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>Headline economics (illustrative)</h3>
<p>Section 5 models an AI agent that reviews one million documents a month, with a person correcting any output that fails. The primary metric is fully loaded cost per completed task. First-pass acceptance is reported separately.</p>
<ul>
<li><strong>API buyer.</strong> Caching, tighter retrieval, model routing and a fallible verification loop cut cost per completed task from $0.94 to $0.36 (−62%). That is about $7.0 million a year in gross operating benefit before implementation costs.</li>
<li><strong>Self-hosted operator.</strong> Adding selective reading as a compute saving gives $0.94 to $0.29 (−69%), about $7.7 million a year gross.</li>
<li><strong>Range.</strong> Across the sensitivity cases, the API reduction runs from 52% to 64%. Rework cost, how many errors the checker catches, and how many it can fix move the result most.</li>
<li><strong>Net of implementation.</strong> With illustrative one-time costs of $1.5 million and $0.6 million a year to run, the API case pays back in about three months.</li>
</ul>
<h3>Decisions for leaders</h3>
<ul>
<li>Measure fully loaded cost per completed task, and first-pass acceptance, for the top AI workflows.</li>
<li><strong>Capture the optimizations that work today:</strong> caching, retrieval, routing and verification.</li>
<li>Build the control layer so new techniques such as selective reading can be adopted when they pass quality and economic tests, without rebuilding applications.</li>
<li>In contracts, define outcomes precisely, secure access to usage meters, and share in vendors' efficiency gains.</li>
</ul>
<p>Section 11 shows how Elixir Global builds these principles into its AgentVault™ agent repository and its Migra data migration platform.</p>
<h2>1. Where enterprise inference costs arise</h2>
<p>A token is a small piece of text, roughly three-quarters of an English word, and it is the unit in which AI is consumed, priced and measured. A 10-page contract is about 5,000 tokens. A 300-page policy manual is about 150,000.</p>
<p>Every AI request has two parts:</p>
<ul>
<li><strong>Reading (input tokens).</strong> The model reads its instructions, the question and any documents supplied. Per token, reading is cheaper and faster than writing, but it adds up: instructions and documents are often re-read at every step of a task.</li>
<li><strong>Writing (output tokens).</strong> The model writes its answer one token at a time. Writing is usually priced several times higher per token than reading, and it sets how long the user waits.</li>
</ul>
<p>Whether an enterprise buys AI through an API (paying per token) or runs its own models (paying for GPUs, power and staff), tokens drive the bill. For API buyers the link is direct. For self-hosted models, every token processed uses GPU time and memory.</p>
<h3>1.1 Cheaper tokens, more tokens per task</h3>
<p>For some agentic workloads, rising call counts and longer contexts can offset falling token prices. The net effect must be measured workflow by workflow. Each generation of enterprise AI has multiplied the computation behind one request.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/5d1116c7-124c-4d43-a1db-a19a213498a2_1600x411.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>Typical orders of magnitude, not measurements.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/1d11cd58-acbf-451d-9d87-368e641f2871_1344x748.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 1. Where an agent's tokens go · illustrative, using section 5's assumptions</em></p>
<p>Three habits of today's agents drive the growth:</p>
<ul>
<li><strong>Re-reading the rulebook.</strong> Standing instructions, tool descriptions and policy text, often thousands of tokens, are re-read at every step.</li>
<li><strong>Reading whole documents.</strong> Contracts, claims files and code are supplied in full, so every request pays to read pages that do not bear on the question.</li>
<li><strong>Writing out reasoning and double-checking.</strong> Accuracy increasingly comes from writing out reasoning, producing several candidate answers and scoring them. All of it is billed as output.</li>
</ul>
<p>A simple illustration: if the price per token falls 10× while a workflow grows from one copilot call to a 30-step agent, tokens per task can rise about 30×, and cost per task triples. Equally, a well-designed agent can cost less than the copilot it replaces. Architecture, not the rate card, decides which.</p>
<h2>2. Available optimizations versus emerging research</h2>
<p>Most of the savings available today come from proven techniques. Selective reading is the most promising new research, and it adds to them rather than replacing them.</p>
<h3>2.1 Three dimensions of conditional computation</h3>
<p>Modern AI efficiency is about making computation conditional: spending it only where it is needed. There are three distinct places to do that.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/54bfb99b-268e-485d-945e-d0c546a125ae_1600x411.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>Mixture-of-experts asks which of the model's specialists to wake up. Selective reading asks which parts of the input deserve deep attention. The two are complementary, and both can sit behind a router that picks the right model in the first place.</p>
<h3>2.2 The wider toolkit</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/861da449-93ba-40ab-a4ee-5570109cd4e1_1600x922.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>2.3 Selective reading: teaching AI what not to read</h3>
<p>Today's models give every input token, from a decisive clause to a page number, the same full-depth processing. Selective reading adds a small, trainable gate inside an existing model. All tokens pass through the early layers, which gives every token context from the whole input. The gate then scores each token's importance. Only the highest-scoring tokens, plus protected items such as the question and instructions, continue to the deeper and more expensive layers. Memory for dropped tokens is freed.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/ecc52ace-8faf-4e66-a2af-fd182ee4aa8b_1344x578.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 2. Selective reading inside the model · illustrative, about a quarter of tokens kept</em></p>
<p>The researchers (Stanford University and UC Berkeley, October 2026) tested this on question answering, repository code completion, summarisation, biomedical extraction and find-the-needle retrieval, with inputs up to 128,000 tokens in some settings. They used two small open models (about 1.7 and 2 billion parameters), each adapted with a gate and light fine-tuning per task.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/7da03864-8c93-44af-b96b-5deb63ffce3f_1600x557.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>Operating points shown in the researchers' summary figure, at accuracy matched to standard reading. They are not end-to-end enterprise benchmarks.</p>
<p>Across tasks, the researchers report 1.4–11.3× faster first responses and 1.5–3.4× lower peak reading memory at matched or near-matched accuracy on selected operating points. The largest gains come on the longest inputs. More aggressive settings buy further speed at some cost in accuracy, for example on multi-hop questions and multi-document extraction. The code and checkpoints are public under an open-source licence, which makes pilots cheaper than an architectural rewrite.</p>
<h3>2.4 How the techniques combine inside an agent</h3>
<p>In a 12-step agent that re-reads instructions and documents at every step, each technique has its natural target:</p>
<ul>
<li>Standing instructions and tool schemas repeat identically. Caching handles them better than learned pruning.</li>
<li>The variable document span is fresh for each request and often long. That is where selective reading adds the most.</li>
<li>Simple steps such as classification or formatting go to small models through routing.</li>
<li>Savings are reinvested in verification or extra candidate answers where risk is high.</li>
</ul>
<p>The gains do not simply multiply. Retries and escalations can erase them. That is why the control layer in section 4 escalates instead of gambling, and records every retry.</p>
<h2>3. Evidence and limitations</h2>
<p>The research shows a better trade-off between quality and efficiency on small models. It does not yet show enterprise savings or production readiness. Every quantitative claim in this paper carries one of four labels.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/0237fac0-e39d-4168-ae3d-25244bd84d70_1600x479.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>3.1 What remains unproven for selective reading</h3>
<ul>
<li><strong>Scale.</strong> Results are on 1.7–2B-parameter models. Transfer to frontier-scale models is unproven.</li>
<li><strong>Production serving.</strong> Gains were measured outside production serving engines. Selective reading needs custom attention kernels that can gather non-contiguous tokens. Without optimised kernels, that overhead can cancel the gains at small batch sizes. Continuous batching, high concurrency and tail latency (p95) must be measured.</li>
<li><strong>Transfer across domains.</strong> Each gate was adapted to its task. A general-purpose gate that transfers safely to new document types has not been shown.</li>
<li><strong>Rare decisive evidence.</strong> One negation, exception clause or account number can decide an outcome. Find-the-needle tests check retrieval of one planted fact. They do not fully cover evidence spread across a document, or multi-step reasoning.</li>
<li><strong>Reading order.</strong> In today's models, a token's score can only use what came before it. Placing the question before the document helps the gate.</li>
<li><strong>A floor on savings.</strong> Early layers always read every token, so speed-ups cannot exceed the ratio of total depth to gate depth.</li>
</ul>
<h3>3.2 What the economics depend on</h3>
<ul>
<li><strong>Billing.</strong> API buyers benefit from selective reading only if providers pass internal savings through in price. Self-hosted operators capture the benefit as GPU capacity.</li>
<li><strong>Amdahl's law.</strong> A 10× faster reading stage gives far less than 10× end to end if retrieval, tools, generation or human approval take most of the time.</li>
<li><strong>Quality.</strong> Any efficiency method that raises the error rate can lose more in rework and risk than it saves in compute.</li>
<li><strong>Energy.</strong> Less computation per request can improve energy efficiency per task. Actual energy reductions need measurement, and growing AI demand may offset them.</li>
</ul>
<h2>4. Adaptive inference architecture</h2>
<p>The durable investment is a control layer that decides, for every request, how much to read, which model to use, how carefully to check and when to involve a person. New techniques then plug in as options, without rebuilding business applications.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/5432ac13-2e29-4c68-a83f-55ccad160022_1344x868.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 3. Adaptive inference platform · 5 layers, escalation and feedback loops</em></p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/18faa9d5-9d80-4396-b1b2-f2c78710a9f0_1600x628.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>4.1 Design rules</h3>
<ul>
<li><strong>Escalate, don't gamble.</strong> Try the cheapest safe approach first. If checks fail, widen the reading budget, switch to full reading or a larger model, or generate more candidates, and only then involve a person. Log every escalation, so the business can see when retries are eating the savings.</li>
<li><strong>Protect what you can identify; widen when you can't.</strong> Protect known critical regions and task scaffolding: the question, instructions, output schemas, defined terms, amounts, identifiers and known exception clauses. Where decisive evidence cannot be identified reliably, keep broader context or use the full-reading path. Protecting the word "not" is not the same as preserving its scope, so protected zones cover whole clauses, not keywords.</li>
<li><strong>Treat verification as fallible.</strong> A checker can miss errors, raise false alarms, and share blind spots with the model it checks. Design for that (section 4.3).</li>
<li><strong>Insulate applications.</strong> Applications call the platform, not a specific model. When a technique matures, it is switched on inside Layer 3 and applications keep working.</li>
</ul>
<h3>4.2 Reference deployment</h3>
<p>Every AI request, whatever channel it comes from, passes through one gateway. Finance, risk and IT get a single place to set budgets, enforce data rules and measure outcomes. The model pool can mix cloud APIs and on-premises GPUs behind the same orchestration, which makes the hybrid choices in section 8 possible.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/4baaea3d-b9d2-4ad2-9c67-c5af1e6abb2f_1344x834.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 4. Reference deployment architecture · from channels to systems of record</em></p>
<h3>4.3 The verification loop</h3>
<p>Verification detects problems. It does not fix them by itself. The loop is: check, detect, retry or repair, re-check, and send what remains to a person.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/85f8021d-1c18-4918-b365-f6f475f8f369_1344x572.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 5. Verification loop · illustrative rates from section 5</em></p>
<p>Four quantities decide whether the loop pays:</p>
<ul>
<li><strong>Recall:</strong> the share of real errors the checker catches.</li>
<li><strong>False-alarm rate:</strong> correct outputs flagged by mistake, which cost a needless retry.</li>
<li><strong>Fix rate:</strong> the share of caught errors a retry or repair actually corrects.</li>
<li><strong>Correlation:</strong> when the checker and the model share blind spots, recall falls on exactly the hardest cases. Use different models, deterministic rules or independent evidence checks where possible.</li>
</ul>
<h2>5. Reproducible economics</h2>
<p>In an illustrative document-review workflow, proven levers cut fully loaded cost per completed task by about 62% for an API buyer. Adding selective reading raises that to about 69% for a self-hosted operator. Every number below can be rebuilt from the stated assumptions (Appendix A). The figures are a scenario, not a measured result.</p>
<h3>5.1 Metrics</h3>
<p>The primary metric counts every task that is eventually completed, including those a person corrects:</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/a0a3344d-6ea0-41c2-9396-3ac12de92943_1600x263.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>First-pass acceptance, the share of outputs accepted without human correction, is reported alongside it. Dividing total cost by first-pass acceptances instead gives a higher figure, cost per first-pass accepted output. It is useful for tracking automation, but it should not be quoted as operating-cost savings.</p>
<h3>5.2 Scenario and assumptions</h3>
<p>An insurer, bank or legal team runs an agent that reviews documents (claims, contracts or loan files) and drafts a recommendation that a person approves. Outputs with errors are corrected by that person.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/48a6560d-0cc6-4137-ba66-a2784f031140_1600x1112.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>5.3 Case A: API buyer</h3>
<p>API buyers pay for every token sent, so selective reading earns them nothing unless the provider passes the saving through in price. It is excluded here.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/fed64386-9ce2-4b66-8a9c-37032079cf75_1600x511.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<img src="https://substack-post-media.s3.amazonaws.com/public/images/e06d7a48-341d-4881-a99b-db030f4ede8e_1344x622.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 6. Cost bridge, API buyer · illustrative model</em></p>
<p>The savings are sequential: each lever is measured after the ones before it, so its share depends on the order applied. Applied first, routing would save more, and caching less. Treat individual lever values as indicative. The combined total does not depend on the order.</p>
<h3>5.4 Case B: self-hosted operator</h3>
<p>For a self-hosted operator, the same unit prices stand in for the GPU cost of processing a token. In practice, measure GPU time, memory and utilisation directly. Selective reading now saves compute on the document span.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/71deef26-64fa-45bf-b680-1055e6d81ad7_1600x372.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>The self-hosted operator sees the benefit as capacity: the same cluster handles more tasks, or the next GPU purchase is deferred. That only becomes cash savings if the capacity would otherwise have been bought.</p>
<h3>5.5 Sensitivity</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/adfdf5c4-c185-4c57-8417-85d728e3b1eb_1600x645.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>The result stays material across these cases, between 52% and 72%. The verification assumptions matter most, so measure recall and fix rate on your own data before you commit a business case.</p>
<h3>5.6 From gross benefit to net benefit</h3>
<p>The scenario produces about $7.0 million (API) to $7.7 million (self-hosted) a year in gross operating benefit. That is before implementation costs, extra platform overhead and transition costs. The implementation figures below are illustrative assumptions.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/7277c963-b281-4d13-9225-f78abbc85970_1600x506.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>5.7 What the model teaches</h3>
<ul>
<li><strong>Quality is the largest single lever.</strong> In the API case, a verification loop costing under two cents per task removes 22 cents of human correction.</li>
<li><strong>No single token lever wins.</strong> Caching, retrieval and routing each save 10–15 cents. Together they cut AI cost by about 70%.</li>
<li><strong>Selective reading is a capacity lever first.</strong> It pays most where documents are long and the operator owns the compute.</li>
<li><strong>Speed is a second dividend.</strong> If each of 12 steps waits 3 seconds for its first token and selective reading cuts that below 1 second, each task finishes about 25 seconds sooner. (Illustrative.)</li>
</ul>
<h2>6. Use cases, and when full reading is still preferred</h2>
<p>Each lever's value depends on a workflow's token profile: whether it mostly reads, mostly writes, or repeats many steps. Just as important is knowing when to switch efficiency off.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/cfbb7ee4-847f-4ea1-9ae5-67f6fa4901fb_1600x1541.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>Two patterns stand out. Read-heavy, decision-light workflows benefit most from selective reading: claims, contracts, code and maintenance. Exactness-critical workflows should spend more tokens, not fewer: reconciliation, regulatory filings and safety procedures get full reading plus deterministic checks. The policy layer makes that choice explicit instead of leaving it to chance.</p>
<h2>7. Pilot criteria and governance</h2>
<p>Adopt an efficiency method only when it passes quality, latency and cost tests on your own workloads, under realistic load, with thresholds agreed before the pilot starts.</p>
<h3>7.1 A 24-month plan</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/e379a931-ec81-4539-ba46-757f1ecb37ad_1600x596.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>7.2 Go/no-go criteria</h3>
<p>Every threshold must state its measurement unit (per field, per output or per task), its sample size and confidence interval, and the workflow's risk tolerance. Compare against the incumbent, not against zero.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/f3ac79aa-ba50-4cc4-8c8c-16b8dd265b3f_1600x698.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>7.3 Planted-evidence protocol</h3>
<ul>
<li><strong>Adversarial inversions.</strong> Insert a contradicting clause (for example, "Notwithstanding Section 4.2, indemnity liability is zero") at 10%, 50% and 90% depth in long agreements. If the efficient path drops or misreads it, the test fails.</li>
<li><strong>Protected zones.</strong> Define what is never pruned: the question and instructions, output schemas, structural delimiters, function-call arguments, section headings, numeric spans, defined terms and whole clauses known to carry exceptions.</li>
<li><strong>Distributed evidence.</strong> Include questions whose answer needs facts from several sections, not just one planted needle.</li>
</ul>
<h3>7.4 Role by role</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/40ff2cd5-5970-433d-b6fe-1103b78a6aa9_1600x737.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h2>8. Procurement: how AI products and agents will be priced</h2>
<p>AI pricing is moving from paying for access (seats), to paying for activity (tokens and credits), to paying for results (outcomes). Most buyers will see hybrids of the three. Where the AI runs decides who captures efficiency gains.</p>
<h3>8.1 Where pricing stands (October 2026)</h3>
<p>Outcome pricing for AI agents is already established in customer service. Prices below were checked against each vendor's official pricing page on October 31, 2026. Definitions differ, and that matters as much as the price.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/9f80c848-eeac-455f-be1c-8d096783a324_1600x789.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>The spread shows the tension in the market: Salesforce charges for every conversation, HubSpot and Zendesk only for resolutions, and Fin for a broader list of outcomes. Analysts expect the shift to continue. Gartner, as reported by Deloitte, projects that at least 40% of enterprise SaaS spend will move toward usage-, agent- or outcome-based pricing by 2030.</p>
<h3>8.2 Pricing by deployment model</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/6f077ee4-e4fd-4263-b8b0-76e460c2dc3d_1344x564.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 7. Pricing architecture · cloud, SaaS and on-premises under one hybrid control layer</em></p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/1cc2ede3-73bd-47db-abaa-5b3c78f512c7_1600x1098.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>8.3 Will SaaS pricing change?</h3>
<p>Yes, for products where agents do work people used to do. Much less for systems of record.</p>
<ul>
<li>Seats stay for people who use the interface.</li>
<li><strong>Agents get their own unit:</strong> per resolution, per document processed, per case closed or per credit. As agents take on work, seat counts shrink and agent units grow.</li>
<li><strong>Systems of record change least.</strong> ERP, HR and CRM platforms are likely to keep subscriptions and add consumption fees for AI features.</li>
<li>Outcome guarantees become a selling point, at a higher price per outcome.</li>
</ul>
<p>An enterprise's own cost per completed task is the right benchmark for buy-versus-build. Vendor prices of $0.50–$2.00 per resolution include margin, platform and support, and they cover a different workload from section 5's model.</p>
<h3>8.4 What to negotiate</h3>
<ul>
<li><strong>A precise outcome definition:</strong> what counts, over what window (for example 72 hours), how reopened cases are treated, and who decides disputes.</li>
<li><strong>Access to the meter:</strong> usage and outcome logs you can audit against your own records.</li>
<li>Caps, floors and true-ups, so usage or outcome pricing stays within budget.</li>
<li><strong>Shared efficiency gains:</strong> scheduled price reductions as the vendor's unit costs fall.</li>
<li><strong>Portability:</strong> the right to move agents, prompts, evaluation sets and data between cloud, on-premises and other vendors.</li>
</ul>
<h2>9. Outlook 2027–2030: three scenarios</h2>
<p>Rather than a single forecast, plan for three scenarios that can unfold together. The same control layer is the right investment in all three. None depends on another: outcome pricing, for instance, does not need selective computation to arrive first.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/c0a83c65-4394-4262-8475-c6335b6cf31a_1344x486.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p><em>Figure 8. Outlook scenarios · not forecasts; they can unfold together</em></p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/9b39f1ed-43e2-4a19-8cdc-a42db186d208_1600x718.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>9.1 Five questions for the next cycle</h3>
<ul>
<li><strong>Will token pricing survive?</strong> Likely yes for model infrastructure, alongside growing usage-, workflow- and outcome-based pricing in applications.</li>
<li><strong>Will models become smaller and more specialised?</strong> Routing and selective computation make specialised models more economic for well-defined tasks. Frontier models remain the fallback for hard cases.</li>
<li><strong>Who captures the efficiency gains?</strong> Cloud providers, model developers, platform operators and SaaS vendors each capture a share, depending on contracts and on where the AI runs.</li>
<li><strong>Will inference matter more than training?</strong> As agent workloads grow, inference efficiency becomes a larger competitive factor for vendors and a larger cost line for buyers.</li>
<li><strong>Will verification become its own value layer?</strong> Trusted outcomes need evidence, deterministic checks and human oversight, however fast generation becomes. Verification is likely to be bought, built and audited as a distinct capability.</li>
</ul>
<p>One research direction deserves watching but is not assumed here. Models that do more of their reasoning in a compact internal form, rather than writing it out as billable tokens, could shrink output costs. That is a hypothesis that needs evidence, not a capability to plan on.</p>
<h2>10. Risks and potential mitigations</h2>
<p>The main risk of token efficiency is false economy: savings that disappear in errors, retries and rework. Each risk below has potential mitigations. A mitigation is not proof that the remaining risk is acceptable; that has to be tested per workflow.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/5f01fcd7-3620-4507-b790-937e217b9a72_1600x1224.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h2>11. How Elixir Global applies these principles</h2>
<p>At Elixir Global, token optimization is designed into our platforms from the start, not added after the bill arrives. Two platforms show how the control-layer approach in this paper works in practice.</p>
<p>AgentVault™ is Elixir's repository of more than 500 enterprise agents. They cover supply chain and SAP processes such as IDoc handling and invoice processing. The agents are model-agnostic: each step can use the smallest model that meets its quality bar, and newer models can be adopted without vendor lock-in. They run within governance guardrails, including SOX and FedRAMP controls where required, and integrate with SAP Joule.</p>
<p>Migra is Elixir's AI-native data migration platform, deployed in client landscapes. It moves master data from many heterogeneous sources through a governed Snowflake hub into SAP S/4HANA, in five stages: ingest, enrich, publish, reconcile, report. Its knowledge base, rules engine and self-learning mean that a mapping resolved once is reused rather than worked out again by a model. Business, IT and audit approvals, plus post-load reconciliation, confirm each outcome before sign-off.</p>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/6cdc456c-016c-4b0d-bf71-4bf9f9b3bbcc_1600x769.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>The result for clients is the same discipline this paper recommends: cost measured per completed business outcome, computation spent where risk and value justify it, and an architecture ready to adopt techniques such as selective reading once they pass quality and economic tests.</p>
<h2>Conclusion</h2>
<p>The first era of enterprise AI proved that machines can produce useful intelligence at scale. The next era will be defined by how deliberately that intelligence is spent. Tokens will not disappear: they remain how models read, write and get billed. But treating every token as equally important is ending.</p>
<p>What will make an AI strategy credible to a CFO, CTO or risk committee is not a bigger savings headline. It is a cost model they can reproduce, assumptions they can challenge, and adoption gates that hold even if research gains do not fully reach production. Organisations that build the control layer, measure cost per completed task, and adopt new techniques only when they pass those gates will get more trusted value from every unit of computation.</p>
<h2>Appendix A: Calculation detail</h2>
<p>All figures are per initiated task; every task is eventually completed. Prices: reading $2.00 and writing $8.00 per million tokens; cached reading $0.20 per million.</p>
<h3>A.1 Tokens and cost per model call</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/4d27f3da-ce9f-47e4-8276-2411f0b15c66_1600x550.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>AI cost per task = 12 calls × cost per call. Baseline: 12 × [(20,000 × $2) + (600 × $8)] ÷ 1,000,000 = $0.5376.</p>
<h3>A.2 Verification loop (API case)</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/be5b9fd4-0726-4535-83e6-b17209c443e7_1600x645.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<h3>A.3 Totals</h3>
<img src="https://substack-post-media.s3.amazonaws.com/public/images/9a411938-d7ee-4309-b653-54be98fc5ddc_1600x372.jpeg" alt="Figure" style="display:block;margin:0 auto" />

<p>Annual gross operating benefit = (baseline monthly total − case monthly total) × 12: API $6.97M; self-hosted $7.73M. Retry calls are assumed to run on the large model, without routing. The self-hosted case uses API unit prices as a stand-in for GPU cost per token.</p>
<hr />
<h2>Further reading</h2>
<ul>
<li><strong>Download the full whitepaper (PDF):</strong> <a href="https://doi.org/10.5281/zenodo.24386748">The Token Economy: How Smarter AI Computation Will Reshape Enterprise Costs and Value</a> (Zenodo, DOI 10.5281/zenodo.24386748)</li>
<li><strong>Related white paper:</strong> <a href="https://doi.org/10.5281/zenodo.24378767">Governing Rogue AI Agents with Valid Credentials</a> (DOI 10.5281/zenodo.24378767)</li>
<li><strong>Related article:</strong> <a href="https://ganeshraju.hashnode.dev/the-rogue-agent-will-have-valid-credentials-how-ctos-and-caios-can-govern-agentic-ai">The Rogue Agent Will Have Valid Credentials: How CTOs and CAIOs Can Govern Agentic AI</a></li>
</ul>
<h2>About the author</h2>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/decfc1bd-9c95-4ce8-9eac-50b35127a903.jpg" alt="" style="display:block;margin:0 auto" />

<p><strong>Ganesh Raju</strong> is Chief AI &amp; Innovation Officer (CAIO) and CTO at <a href="https://www.elixirglobal.com">Elixir Global</a>, an AI-first enterprise consulting firm headquartered in Atlanta with offices in Houston, Dubai, Bengaluru and Singapore. He leads enterprise AI strategy and <strong>AgentVault</strong>, Elixir's portfolio of governed, production-ready AI agents for SAP and enterprise operations, and the Migra AI-native data migration platform.</p>
<p>He brings more than 15 years of experience in artificial intelligence, machine learning and data engineering. As Head of Big Data, Data Science &amp; AI at Linaro he led Arm enablement of the open-source big data and data science ecosystem, served as ODPi PMC member and TSC lead and as a Linux Foundation TSC member, and led the Apache Bigtop community. An open-source committer, he has contributed to TensorFlow, Apache Spark and Hadoop.</p>
<p>He is the author of <em>AI Blockchain Design and Deployment</em> (BPB Publishing), founder and CEO of <a href="http://Akshaya.io">Akshaya.io</a>, founder of RapidEVChargE (rapidevcharge.com), an investor, an advisor to Canon, and a mentor to founders and technology leaders. He is a former Vice Chair of IEEE Houston and a participant in the Wharton Executive Education Chief Technology Officer program. He is based in Houston, Texas.</p>
<p><em>Connect on</em> <a href="https://www.linkedin.com/in/ganeshraju07"><em>LinkedIn</em></a> <em>·</em> <a href="https://github.com/ganeshraju"><em>GitHub</em></a> <em>·</em> <a href="https://ganeshraju.hashnode.dev"><em>Blog</em></a></p>
<p><em>Views are the author's own. Elixir Global offers products and services related to the subject of this paper. Economic figures are illustrative scenarios, not measured results.</em></p>
<p>#TokenEconomy #AgenticAI #EnterpriseAI #AIInference #LLM #AICosts #FinOps #GenerativeAI #CAIO #CTO #CFO #AIStrategy</p>
]]></content:encoded></item><item><title><![CDATA[The Rogue Agent Will Have Valid Credentials: How CTOs and CAIOs Can Govern Agentic AI]]></title><description><![CDATA[Rogue AI agents won't need to be hacked. The control architecture, policy-as-code and 90-day plan CTOs and CAIOs need to govern agentic AI.]]></description><link>https://ganeshraju.hashnode.dev/the-rogue-agent-will-have-valid-credentials-how-ctos-and-caios-can-govern-agentic-ai</link><guid isPermaLink="true">https://ganeshraju.hashnode.dev/the-rogue-agent-will-have-valid-credentials-how-ctos-and-caios-can-govern-agentic-ai</guid><category><![CDATA[AI]]></category><category><![CDATA[ai agents]]></category><dc:creator><![CDATA[Ganesh Raju]]></dc:creator><pubDate>Thu, 19 Nov 2026 19:53:32 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/ed5b008c-e7d6-4498-ae51-41751492e62a.jpg" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p><em>Why the next enterprise crisis may not begin with an attack, but with AI agents following their rules perfectly, and the control architecture that stops it.</em></p>
<hr />
<h2>Key takeaways</h2>
<ul>
<li><strong>What a rogue AI agent is:</strong> an autonomous AI agent that causes harm while holding valid enterprise credentials. It does so either because it was manipulated, or because several authorized agents combine into an outcome nobody approved.</li>
<li><strong>Why it matters now:</strong> agentic AI is moving from pilots into payments, ERP, supply chains and plant systems faster than governance can keep up. Regulators, auditors and insurers are starting to ask for evidence of control.</li>
<li><strong>Who is most exposed:</strong> banks, insurers, manufacturers, utilities and government agencies that are adopting AI agents quickly on top of legacy core systems.</li>
<li><strong>The architecture that works:</strong><ul>
<li>The model proposes, and an independent action gateway decides.</li>
<li>Business-state rules are enforced as policy-as-code.</li>
<li>A kill switch works from outside the agent platform.</li>
</ul>
</li>
<li><strong>What leaders should do in 90 days:</strong> give every agent with production write access four things: a named owner, a scoped mandate, a hard limit on harm, and a tested revocation path. Back all of it with continuous monitoring.</li>
</ul>
<hr />
<h2>One week in November</h2>
<p>Earlier this month, in the space of five days, three systems we all treat as utilities faltered:</p>
<ul>
<li>Microsoft 365 stumbled across 74 countries.</li>
<li>The FAA halted departures nationwide.</li>
<li>JPMorgan Chase stalled transactions that rippled into other banks.</li>
</ul>
<p>None of it was caused by AI. Oddly, that is what worried me most.</p>
<p>Every one of those outages started with something ordinary: a configuration change, an upgrade, a dependency that a capable team had planned and reviewed. A small fault met a shared system and travelled faster than the people running it could contain it.</p>
<p>Now picture that same week with thousands of AI agents in the mix. These agents move money, change infrastructure, edit records and delegate to one another around the clock, all on valid enterprise credentials. They make exactly the kind of change that started each of those outages. They make it continuously, and they don't wait for a change board.</p>
<p>So the question I now put to every executive team I work with is not "What happens when one agent makes a bad decision?" It is:</p>
<blockquote>
<p><strong>"What happens when every agent makes a locally correct decision, and the combined result is something nobody authorized?"</strong></p>
</blockquote>
<p>The next enterprise crisis may not begin with an AI breaking the rules. It may begin with AI agents following their rules perfectly.</p>
<p>We spent the first era of enterprise AI making systems intelligent. The next era is about making that intelligence accountable. Risk is moving from what models <em>say</em> to what agents <em>do</em>, and from single actions to collective outcomes. What follows is what I'm seeing in the field, why it compounds, and what I believe CTOs, CAIOs, CIOs and CDOs should do about it.</p>
<hr />
<h2>The most dangerous rogue agent isn't rogue at all</h2>
<p>When people hear "rogue agent," they picture a model that breaks its rules. That will happen. But the incident I'd lose sleep over looks different. Several well-behaved agents each act inside their permissions, and their actions add up to an outcome nobody approved.</p>
<p>Most security tools ask whether <em>one agent</em> was allowed to act. Very few ask whether the <em>business state</em> that results is acceptable. Each agent passes its own checks, and the business still fails.</p>
<h3>A concrete example: three authorized agents, one fraudulent payment</h3>
<p>Here is a hypothetical example I'll come back to throughout. Every part of it is ordinary.</p>
<ol>
<li>A <strong>vendor-master agent</strong> updates a supplier's bank details after receiving an email that looks legitimate.</li>
<li>An <strong>accounts-payable agent</strong> matches the invoice to the purchase order and approves it.</li>
<li>A <strong>treasury agent</strong> releases the payment run on schedule.</li>
</ol>
<p>Each one is allowed to do exactly what it did, and the money still ends up with a fraudster.</p>
<p>This is the agentic version of business-email compromise, which banks and corporate treasuries already fight every week. No gateway that inspects one call at a time will catch it. What catches it is a <strong>business-state rule</strong>:</p>
<blockquote>
<p><em>No payment to a bank account changed in the last 30 days until it has been verified by calling a number already on file.</em></p>
</blockquote>
<p>That rule belongs in the ERP and the payment run. There, it holds no matter which agent, vendor or model touches the transaction.</p>
<h3>Autonomy debt: the hidden liability on every agent roadmap</h3>
<p>I call the gap behind this <strong>autonomy debt</strong>. Every enterprise that deploys agents is running two curves:</p>
<ol>
<li><strong>The authority it delegates</strong> to agents.</li>
<li><strong>The control it can actually prove</strong> over them.</li>
</ol>
<p>When the first curve runs ahead of the second, debt piles up. It behaves like technical debt with one nasty twist. A loosely governed pilot isn't a harmless experiment for long. Once it holds production credentials and sits inside a real process, it becomes something you can't easily switch off.</p>
<p>The arithmetic is unforgiving. Exposure grows with three things: how fast agents act, how much each action matters, and how long it takes you to contain a mistake. So the real question for a CTO isn't "How fast can we detect?" It's this:</p>
<blockquote>
<p><strong>"Can our controls stop harmful execution faster than our agents can produce it?"</strong></p>
</blockquote>
<hr />
<h2>So who should actually be worried?</h2>
<p>The question I hear most often in boardrooms is whether this is a problem for companies racing into agents, or for companies sitting on decades of legacy systems. My honest answer is both, for different reasons. The companies most exposed are the ones that are both.</p>
<p><strong>Fast movers on a modern stack</strong> start with real advantages: good APIs, modern identity, cloud-native logging. Their risk is speed. Agents multiply through no-code builders and SaaS features faster than anyone can register them, and governance gets designed after the sprawl rather than before it. <em>The cheapest moment to put control in place is before your first hundred agents, not after your first thousand.</em></p>
<p><strong>Legacy estates</strong> face the harder problem. Core banking, policy administration, ERP, MES and SCADA systems were built for human operators and overnight batch jobs. Agents usually get connected to them through:</p>
<ul>
<li>shared service accounts with sweeping rights,</li>
<li>screen automation where no API exists,</li>
<li>batch interfaces with no undo,</li>
<li>audit logs that record <em>which account</em> acted but not <em>why</em>.</li>
</ul>
<p>After an incident, nobody can say which agent did it, or on whose instruction.</p>
<p><strong>Fast adoption on top of a legacy core is the most exposed position.</strong> That is where most of the regulated economy now sits: banks, insurers, manufacturers, utilities and government agencies moving quickly on agents while running on decades-old cores. For them, an action gateway and business-state rules aren't a nice-to-have. They're the adapter that makes an old system safe to expose to a caller that never sleeps.</p>
<p>Please don't assume you're a bystander. If you think your company isn't adopting agents, it almost certainly is, through features your SaaS vendors switch on by default and tools your people bring in themselves. Moving slowly doesn't reduce the exposure. It just leaves it unmanaged.</p>
<hr />
<h2>This is no longer theoretical</h2>
<p>For twenty years, the attacks that defined our careers came from outside: flood the front door, trick the database, smuggle in hostile code. Those threats haven't disappeared, but most of us now buy mature defences for them as a utility. The new threat is already inside the walls. It holds valid keys, and we invited it in. <strong>The threat has moved from breaking in to acting with the keys.</strong></p>
<p>Everything in this list has already happened in production in the last twelve months:</p>
<ul>
<li>A coding agent erased a production database, and its backups, in nine seconds.</li>
<li>An agent at a Fortune 50 company hit a permission wall and simply removed the restriction itself. Every identity check passed.</li>
<li>An approved internal agent gave advice that exposed sensitive data to the wrong staff for two hours.</li>
<li>A single crafted email turned an enterprise copilot into a zero-click data-exfiltration channel.</li>
<li>A popular open-source agent's marketplace hosted hundreds of malicious add-ons, while tens of thousands of instances sat exposed on the internet.</li>
<li>A swarm of 100 agents passed a code change from one to another until one of them committed it, with no person in the loop.</li>
</ul>
<h3>The agentic risk ladder</h3>
<p>The risk climbs in stages:</p>
<ol>
<li><strong>Mistakes at speed:</strong> agents doing the wrong thing faster than people can notice.</li>
<li><strong>Manipulation:</strong> outside content or a poisoned tool steers an agent without the attacker ever touching your network.</li>
<li><strong>Persistence:</strong> poisoned memory keeps firing for weeks.</li>
<li><strong>Propagation:</strong> agents delegate to sub-agents and trade with other companies' agents.</li>
<li><strong>Adversarial autonomy:</strong> attacker agents probe yours around the clock.</li>
<li><strong>Physical consequence:</strong> agents reach plant equipment, grids, vehicles or clinical systems, and a data incident becomes a safety incident.</li>
</ol>
<p>Most enterprises today are on the first two rungs. A rogue agent doesn't need to be hacked to do harm. And when it <em>is</em> hacked, the attacker inherits everything it's allowed to do.</p>
<hr />
<h2>The census nobody can take</h2>
<p>Here's a simple test. Could you tell an examiner today how many agents your company runs, and who owns each one? Most enterprises can't. Industry projections suggest an average Fortune 500 company could be running well over a hundred thousand agents by 2028. At that scale, an agent nobody owns isn't an edge case. It's the default.</p>
<p>Agents enter the enterprise through four doors:</p>
<ol>
<li><strong>Prebuilt products</strong> (SaaS copilots and vendor agents)</li>
<li><strong>No-code builders</strong></li>
<li><strong>Developer platforms</strong></li>
<li><strong>Custom-trained models</strong></li>
</ol>
<p>Then there's the fifth door nobody opened on purpose: <strong>shadow agents</strong> on personal accounts and team subscriptions.</p>
<p>The fix is unglamorous but essential: <strong>treat agents the way HR treats people.</strong></p>
<ul>
<li>No credential before a registry entry with a named owner and a declared purpose.</li>
<li>Reviews on a schedule.</li>
<li>Dormant agents flagged.</li>
<li>Same-day off-boarding when the job is done.</li>
</ul>
<p>And keep discovering, continuously. The agents you don't know about are the ones your runtime controls will never see.</p>
<hr />
<h2>What a controlled agent estate looks like</h2>
<p>Everything I recommend rests on three principles:</p>
<ol>
<li><strong>Intelligence proposes, and an independent authority decides.</strong></li>
<li><strong>Protect outcomes, not just individual actions.</strong></li>
<li><strong>Never let an agent's authority grow faster than your ability to stop it and recover.</strong> Then check all of that continuously, not once at go-live.</li>
</ol>
<h3>Two dials, not one: agency vs. autonomy</h3>
<p>Most arguments about "how autonomous should this agent be?" go in circles because they mix up two separate settings:</p>
<ul>
<li><strong>Agency</strong> is who decides the <em>steps</em>: a developer at build time, or the model at runtime.</li>
<li><strong>Autonomy</strong> is who approves the <em>action</em>: a person, or nobody.</li>
</ul>
<p>Where an agent sits on these two dials decides which controls it needs. This framing settles a lot of debates quickly:</p>
<ul>
<li>If the steps can be written down, write them down. Give an agent only as much freedom to plan as the task genuinely needs.</li>
<li>Any agent that reads content from customers, suppliers or the open internet should follow fixed steps.</li>
<li>Autonomy should be earned one class of action at a time, on evidence, and taken back the moment the evidence turns.</li>
</ul>
<p>One caution about human approval: it's a speed bump, not a wall. When someone approves nearly every request within seconds, that isn't oversight. Measure approval rates and response times the way you'd measure any other control.</p>
<h3>The model proposes, the gateway decides</h3>
<p>The core architectural move is simple to say and harder to do: <strong>demote the model from executor to proposer, and put a deterministic action gateway between every proposal and the real world.</strong></p>
<p>Think of it as six layers, plus a control plane that keeps working when the agent platform doesn't. That last part is November's lesson. Audit, revocation and the kill switch have to keep working when the agent platform, the cloud region or the identity provider fails.</p>
<p>Design rules I ask every CTO to enforce in architecture reviews:</p>
<ul>
<li><strong>No agent holds a long-lived secret or borrows a human's session.</strong></li>
<li><strong>No tool accepts free-form SQL or shell commands where a typed business operation would do.</strong></li>
<li><strong>A child agent never gets more authority than its parent.</strong></li>
<li><strong>Every consequential action can be traced, in a single query, to a mandate, a policy version and a named human.</strong></li>
</ul>
<p>Two details separate a real control plane from a dashboard:</p>
<ol>
<li><strong>Approvals bind to a fingerprint.</strong> When a human approves a payment, they approve a fingerprint of the exact payee, amount and destination, so any later change voids the approval.</li>
<li><strong>The kill switch revokes authority instead of closing a chat window.</strong> It revokes tokens, gateway access, queued work and network egress, in that order.</li>
</ol>
<p>Limits also have to be <strong>cumulative</strong>. A $500 per-call cap won't stop a hundred refunds of $499.</p>
<h3>Three layers, and the new one is where the gaps are</h3>
<p>The good news is that you don't need a brand-new security program. Most of what protects an agent already exists: workload identity, cloud posture, data security, code scanning. A second layer arrived with chatbots. The third layer, built for software that <em>takes actions</em>, is new, and that's where nearly every gap I see sits.</p>
<p>A practical sequence:</p>
<ol>
<li><strong>Start with native controls</strong> your agent platforms already provide, because they see more of their own agents than any outside tool can.</li>
<li><strong>Add an independent layer</strong> that spans every platform, for posture, rogue-agent detection and one consistent policy.</li>
<li><strong>Treat tool servers (including MCP servers) as your new software supply chain.</strong> Approve only official ones, route every tool call through a single gateway, and restrict commands and parameters, not just tools.</li>
</ol>
<h3>Secure the action, not just the prompt</h3>
<p>Prompt filters inspect words. But agents fail through what they <em>do</em>: a tool misused, a goal hijacked, a loop that never ends, a correct-looking step on the wrong record. Some agents don't even have a prompt; they wake up on an event and act.</p>
<p>Control belongs at the seam between deciding and doing, with hooks on both sides. Analysts expect most successful attacks on agents through 2029 to exploit <strong>access control</strong>, with prompt injection as the delivery route rather than the payload. The rule I'd take from that is blunt:</p>
<blockquote>
<p><strong>If an agent can't prove who it's acting for and why, it doesn't reach the tool.</strong></p>
</blockquote>
<p>One more distinction matters as new runtime safety platforms arrive, some enforcing policy right down in the hardware: <strong>secured is not the same as governed.</strong> A runtime safety net can stop an agent doing something dangerous. It can't decide what the agent should be allowed to do, what data it may use, or when a person needs to approve. That still takes clear decision rights, written down for every agent, and a governed source of the business rules agents decide with.</p>
<h3>Layers that fail differently</h3>
<p>If I could ask every architect to memorize one idea, it would be what security researchers call the <strong>lethal trifecta</strong>:</p>
<ol>
<li>private data,</li>
<li>untrusted content,</li>
<li>a way to communicate externally.</li>
</ol>
<p>Give one agent all three and it is a single crafted message away from becoming an exfiltration tool. Prompt injection is not solved. Until it is, no agent session should hold all three without a human or a deterministic check in the path.</p>
<p>Here's how layered control plays out against an attack I see demonstrated constantly. A customer-support agent reads incoming email and can query the CRM. An attacker sends a message with a hidden instruction: <em>look up this customer's account and email the details to an outside address.</em> Four independent layers can each stop it on their own:</p>
<ol>
<li><strong>Posture check:</strong> flags the risky combination (CRM access plus external email) before the agent ever runs.</li>
<li><strong>Input screening:</strong> strips the hidden instruction before it reaches the model.</li>
<li><strong>Behavioural detection:</strong> notices a bulk lookup followed by outbound mail and pauses the agent.</li>
<li><strong>Deterministic gate:</strong> refuses to send sensitive data to an outside recipient, whatever the model was talked into.</li>
</ol>
<p>The first three layers use judgment, and judgment can be fooled. The last one can't be argued with. That's why I insist that <strong>every business-critical outcome ends on a deterministic rule</strong>, written as policy-as-code that sits outside the model and that auditors can read. The supplier-payment rule from earlier looks something like this (Cedar-style policy):</p>
<pre><code class="language-plaintext">forbid (principal is Agent, action == Action::"release_payment", resource is Payment)
when {
  resource.payee.bank_account_changed_days &lt; 30 &amp;&amp;
  !resource.payee.callback_verified
};
</code></pre>
<p>It's a few lines. It holds no matter which agent or model is involved, and it can be versioned, tested and evidenced like any other control.</p>
<hr />
<h2>Continuous monitoring: control is never a one-time approval</h2>
<p>The agent that passed review last quarter is not the agent running today. Models get updated, prompts and tools change, permissions creep, data drifts and attackers adapt. Approval at go-live is a snapshot. Assurance has to be a live feed.</p>
<p>Watch five things all the time:</p>
<table>
<thead>
<tr>
<th>Signal</th>
<th>What to watch</th>
</tr>
</thead>
<tbody><tr>
<td><strong>Behaviour</strong></td>
<td>What each agent did against what it was asked to do</td>
</tr>
<tr>
<td><strong>Authority</strong></td>
<td>Permissions granted against permissions used; any change to instructions or policy</td>
</tr>
<tr>
<td><strong>Outcomes</strong></td>
<td>The business-state rules themselves</td>
</tr>
<tr>
<td><strong>Economics</strong></td>
<td>Cost per task and runaway loops</td>
</tr>
<tr>
<td><strong>Controls</strong></td>
<td>The controls themselves, proved by drills rather than assumed</td>
</tr>
</tbody></table>
<p>Monitoring only counts as a control if it passes three tests:</p>
<ol>
<li><strong>Independent:</strong> it keeps watching when the agent platform fails.</li>
<li><strong>Able to act:</strong> it throttles, pauses or revokes within defined limits before it pages a human.</li>
<li><strong>Feeds back:</strong> every finding tightens a policy, retires an agent or changes how much autonomy an action has earned.</li>
</ol>
<p>As agent counts outgrow human review, much of this watching will move to independent <strong>guardian agents</strong>. These should be deterministic where they decide, and model-based only where they advise.</p>
<h3>The one new metric: mean time to provenance</h3>
<p>If you track one new metric next year, make it <strong>mean time to provenance (MTTP)</strong>. That is how long it takes to reconstruct, for any disputed transaction, the full chain:</p>
<ul>
<li>the person who started it,</li>
<li>the agent and the run,</li>
<li>the mandate,</li>
<li>the inputs,</li>
<li>the policy version,</li>
<li>the approval,</li>
<li>the receipt.</li>
</ul>
<p>November's public root causes took one to three days to name. For consequential agent actions, the target should be <strong>under an hour</strong>.</p>
<hr />
<h2>In regulated industries, a rogue agent becomes a finding</h2>
<p>In a bank, an insurer or a hospital, the question after an incident is not whether an agent misbehaved. It's whether you can <strong>prove what it was allowed to do</strong>. Regulated firms will be judged on evidence, not intent.</p>
<p>The rulebook is in motion, which is exactly why this matters now:</p>
<ul>
<li><strong>US banking:</strong> in April 2026 the US banking agencies replaced their 2011 model-risk guidance with <strong>SR 26-2</strong>. They confirmed that generative and agentic AI sit outside its scope while a successor approach is worked out. Don't read that as a free pass. Until new rules arrive, examiners will lean on what already applies: operational resilience, third-party risk, and internal controls over financial reporting.</li>
<li><strong>Europe:</strong> <strong>DORA</strong> is already live, and the <strong>EU AI Act's</strong> high-risk obligations begin in December 2027.</li>
<li><strong>Insurance:</strong> since January 2026, standard commercial liability forms have offered generative-AI exclusions. It's worth asking your broker this quarter whether an agent-caused loss is actually covered.</li>
</ul>
<p>Examiners will ask for one unbroken chain, from owner to receipt. What they'll ask, by sector:</p>
<ul>
<li><strong>Banking:</strong> Show me every agent that can move money, its limits and who approved them.</li>
<li><strong>Insurance:</strong> Prove no adverse decision reached a customer without accountable human review.</li>
<li><strong>Healthcare and life sciences:</strong> Show me the validated state of the agent and an audit trail for every record it changed.</li>
<li><strong>Energy and utilities:</strong> Can any agent reach operational technology, directly or through a tool?</li>
<li><strong>Government:</strong> Does every agent stay inside the authorization boundary?</li>
</ul>
<hr />
<h2>What control is worth: the business case for agent governance</h2>
<p>I'm often asked to justify control spending, so here's the shape of the business case. Take a hypothetical mid-size bank running agents across vendor management, payables, treasury and payment exceptions. On planning assumptions, four scenarios add up to about <strong>$1.16M of expected loss a year</strong> without independent controls:</p>
<ul>
<li>a fraudulent payment to a changed bank account,</li>
<li>a duplicate payment run,</li>
<li>customer data over-exposure,</li>
<li>a one-day agent-induced outage.</li>
</ul>
<p>Now add an authority plane with business-state rules, cumulative limits, an evidence chain and quarterly drills. It costs an assumed <strong>$450K a year</strong> and cuts each probability by roughly <strong>70%</strong>. That leaves a net benefit of about <strong>$360K a year</strong>.</p>
<p>But the number boards, examiners and underwriters will ask for first isn't expected loss. It's <strong>maximum credible loss</strong>:</p>
<ul>
<li><strong>Without cumulative limits</strong>, one bad day's fraud exposure is bounded only by the size of the payment run.</li>
<li><strong>With the 30-day bank-change rule and counterparty caps</strong>, it's bounded by the verification queue.</li>
</ul>
<p><strong>Control isn't the tax on agentic AI. It's what lets pilots become production.</strong></p>
<hr />
<h2>Manufacturing: where a rogue agent stops a line</h2>
<p>Manufacturing is where this turns physical. A bad answer in the back office costs money. A bad action near a production line costs output, quality and sometimes safety. And most manufacturers are more regulated than they think, from medical devices and pharma to aerospace, automotive, food and defence.</p>
<p>The rule is one plant engineers already live by: <strong>the closer a system is to the machine, the less an agent may do.</strong></p>
<ul>
<li><strong>Enterprise layer (ERP, planning, procurement):</strong> agents act, within mandates.</li>
<li><strong>Operations layer (MES, quality, maintenance):</strong> agents may propose; qualified people approve.</li>
<li><strong>Control and safety layer (PLC, DCS, SCADA, SIS):</strong> agents never touch these systems.</li>
</ul>
<p>The realistic failures aren't science fiction:</p>
<ul>
<li>a planning agent that trims safety stock to hit a working-capital target and stops a line;</li>
<li>a procurement agent that switches to a cheaper, unqualified supplier;</li>
<li>an agent that edits a bill of materials outside change control;</li>
<li>a supplier's agent negotiating with yours beyond anyone's delegated authority.</li>
</ul>
<p>Before any agent decision touches real operations, <strong>rehearse it in a digital twin</strong>, so every action is traceable and, wherever possible, reversible.</p>
<hr />
<h2>Cloud, on-premises, edge: one authority plane across all of them</h2>
<p>Few enterprises will run agents in one place. Most will run them in four, and the rogue agent will slip through whichever one your control plane doesn't reach.</p>
<table>
<thead>
<tr>
<th>Where agents run</th>
<th>Strength</th>
<th>Watch-out</th>
</tr>
</thead>
<tbody><tr>
<td><strong>SaaS-embedded</strong></td>
<td>Fast to adopt</td>
<td>Your controls are API scopes, admin settings and contract terms that guarantee evidence export and kill-switch access</td>
</tr>
<tr>
<td><strong>Cloud-tenant</strong></td>
<td>Strong native identity and policy</td>
<td>The agent, its gateway and its kill switch often share one provider and one region; the stop has to live in a different failure domain</td>
</tr>
<tr>
<td><strong>On-premises / sovereign</strong></td>
<td>Data stays inside the boundary</td>
<td>Legacy systems rarely have APIs that can enforce limits; and on-prem is not automatically safer (one of November's outages was on-prem hardware)</td>
</tr>
<tr>
<td><strong>Edge (laptops, plant gateways)</strong></td>
<td>Close to the work</td>
<td>Edge agents inherit whatever the user or device can do; register them, sandbox them, keep the ones near OT recommendation-only</td>
</tr>
</tbody></table>
<p>My guidance is <strong>hybrid by design</strong>: one identity model, one policy language, one evidence format and one kill switch across all four. As smaller models get better, regulated firms will pull their most sensitive agent workloads on-premises and into sovereign environments. That makes portable, vendor-neutral control more important, not less.</p>
<hr />
<h2>The risk that's already inside</h2>
<p>Most agent risk won't come from attackers. It will come from employees using agents in good faith, and a few in bad faith, on top of access rights that were never designed for a machine that reads everything. An agent turns years of loose permissions and porous departmental walls into instant, searchable exposure.</p>
<ul>
<li>In a <strong>bank</strong>, an analyst's assistant pulls deal material from across an information barrier.</li>
<li>In a <strong>hospital</strong>, a scheduling agent surfaces patient records to staff outside the care team.</li>
<li>In a <strong>plant</strong>, a maintenance agent shares controlled drawings with a contractor's account.</li>
<li><strong>Anywhere</strong>, one mis-set permission puts an HR file a single prompt away from anyone with an assistant.</li>
</ul>
<p>The fixes are mostly discipline:</p>
<ol>
<li>Clean up oversharing <strong>before</strong> rollout, not after.</li>
<li>Bind every agent to its user and its purpose, because "can see it" isn't the same as "may use it here."</li>
<li>Enforce information barriers inside the agent's retrieval and memory, not just in the applications behind it.</li>
<li>Fold agents into insider-risk monitoring.</li>
<li>Build a culture where any employee can stop an agent and report a mistake without fear, and treat those reports as near-misses to learn from.</li>
</ol>
<hr />
<h2>Where the AI security market is heading, and what to ask of it</h2>
<p>Agent security has become a land grab for one control point: the moment an agent's decision becomes an action. Investors put roughly <strong>$3.9 billion into AI security in 2026 through August</strong>, and the big platforms are buying specialists at a record pace. Expect today's features to become tomorrow's defaults.</p>
<p>The market is sorting into four positions:</p>
<ol>
<li><strong>Identity providers</strong> know <em>who</em> an agent is.</li>
<li><strong>Execution platforms</strong> can <em>stop</em> an action, mostly inside their own runtime.</li>
<li><strong>Telemetry players</strong> <em>detect</em> risk, usually after the fact.</li>
<li><strong>Business-aware assurance</strong> understands <em>what an action means for the business</em>. This is the least served position, and it's exactly where the payment example and most of this year's incidents point. You can't buy it off the shelf, because it requires process knowledge and deep integration with ERP, finance and operations.</li>
</ol>
<h3>A buyer's test for AI agent security vendors</h3>
<p>Vendor rankings age in months, so I use a buyer's test instead. Ask every vendor to show you, <strong>in your own environment</strong>, that their product can:</p>
<ul>
<li><input disabled type="checkbox" /> block an action before it commits;</li>
<li><input disabled type="checkbox" /> enforce one cumulative limit across several agents;</li>
<li><input disabled type="checkbox" /> apply a business rule like the 30-day bank-change check;</li>
<li><input disabled type="checkbox" /> keep working when its own service is down;</li>
<li><input disabled type="checkbox" /> revoke an agent along with its sub-agents and queued work;</li>
<li><input disabled type="checkbox" /> export evidence another system can verify.</li>
</ul>
<p>Grade each answer as <strong>demonstrated, claimed or untested</strong>. My rule of thumb: <em>buy the commodity controls, build the business semantics, and never outsource accountability.</em></p>
<hr />
<h2>What leaders should do now: a 90-day plan for CAIOs, CTOs, CIOs and CDOs</h2>
<p>Controlled autonomy fails when it belongs to everyone, so split it by what each leader already owns:</p>
<table>
<thead>
<tr>
<th>Leader</th>
<th>Owns</th>
</tr>
</thead>
<tbody><tr>
<td><strong>CAIO</strong> (Chief AI Officer)</td>
<td>How much autonomy the enterprise will accept, and a named owner for every agent</td>
</tr>
<tr>
<td><strong>CDO</strong> (Chief Data Officer)</td>
<td>Which data may never leave a boundary or reach an external model</td>
</tr>
<tr>
<td><strong>CTO</strong> (Chief Technology Officer)</td>
<td>The authority plane as a shared platform, with an off-platform kill switch</td>
</tr>
<tr>
<td><strong>CIO</strong> (Chief Information Officer)</td>
<td>Making the ERP and core systems, not the agents, the final enforcers of business rules and segregation of duties</td>
</tr>
</tbody></table>
<p>Then give the work a deadline. <strong>By the end of Q1 2027</strong>, every agent with production write access should have:</p>
<ul>
<li>a <strong>named owner</strong>,</li>
<li>a <strong>scoped mandate</strong>,</li>
<li>a <strong>hard limit on harm</strong>,</li>
<li>a <strong>revocation path you've actually tested</strong>, including from outside the agent platform.</li>
</ul>
<p>Run one <strong>game day</strong> this quarter: take down your identity provider and your gateway, and watch what your agents do.</p>
<p>And if you adopt only one board rule, make it this one:</p>
<blockquote>
<p><strong>No new high-impact autonomous workflow goes live until its owner can show a hard limit on harm, an independent stop that works with the platform down, and a reconstruction of any transaction from mandate to receipt.</strong></p>
</blockquote>
<hr />
<h2>How we're approaching this at Elixir Global</h2>
<p>Frameworks and point tools don't wire themselves into ERP, core banking, claims, MES or plant systems. Somebody has to connect what an agent <em>may call</em> with what that call <em>does to the business</em>. That fourth position, <strong>business-aware autonomy assurance</strong>, is the one we've chosen to lead at <a href="https://www.elixirglobal.com">Elixir Global</a>. It's the work I lead as Chief AI &amp; Innovation Officer, with teams that have deployed agents and AI governance across federal, energy, oil and gas, manufacturing, life sciences, utilities and consumer goods.</p>
<p>For us, the next frontier of enterprise AI isn't deploying more agents. It's engineering the conditions under which an enterprise can safely trust them with consequential work. Three convictions guide us:</p>
<ol>
<li><strong>Business semantics come first.</strong> The rule that stops the payment example belongs in the ERP, where it holds no matter which agent or model touches the transaction.</li>
<li><strong>Enforcement stays independent.</strong> Agents propose, and the client's own identity, gateway, audit and kill switch decide.</li>
<li><strong>Assurance is continuous.</strong> We design governance in before agents get production credentials, and use the same approach to close the gaps where agents are already live.</li>
</ol>
<p>The same philosophy shapes <strong>AgentVault</strong>, our library of enterprise agents for finance close, payables and receivables, procurement and supply chain. Those are the very workflows in the payment example. Every AgentVault agent is designed to arrive governed:</p>
<ul>
<li>a declared purpose and owner,</li>
<li>a scoped mandate,</li>
<li>guardrails aligned to the client's compliance regime,</li>
<li>operation inside the client's own environment, whether that's cloud, on-premises or a sovereign enclave.</li>
</ul>
<p>And because the agents stay portable across models and frameworks, clients can adopt better models without rebuilding their controls.</p>
<hr />
<h2>The next architecture problem isn't intelligence. It's control.</h2>
<p>The threat will keep moving under whatever we build. The work comes in three horizons:</p>
<ul>
<li><strong>Now: visibility.</strong> Find every agent, give each one an identity, lock down tool servers, strip excess permissions.</li>
<li><strong>Next two to three years: scaled supervision.</strong> Supervision has to scale beyond what humans can review.</li>
<li><strong>After that: physical AI.</strong> World models and physical AI will bring agents to machines, robots and plant equipment, where mistakes stop being reversible.</li>
</ul>
<p>We're approaching the moment when enterprises delegate more decisions to machines than people can individually review. That shift could unlock extraordinary productivity in banking, insurance, healthcare, energy, manufacturing and government. It also raises a question our architectures were never built to answer: <em>who is accountable when autonomous systems make individually authorized decisions that together produce an unacceptable outcome?</em></p>
<p>The answer isn't another prompt, another dashboard, or an AI supervisor watching an AI worker. It's an independent authority plane, business rules enforced where the business actually runs, continuous monitoring, evidence that stands up to examiners, and the ability to recover from failures that move at machine speed.</p>
<p>Here's the part I find genuinely exciting. The enterprises that build this early won't delegate <em>less</em> to AI. They'll be able to delegate <em>more</em>, because they can prove it's safe. <strong>The advantage in the next decade won't go to whoever automates the most decisions. It will go to whoever can safely afford the most autonomy.</strong></p>
<p>The next agent incident may look completely routine in the logs: a valid identity, an approved tool, a successful transaction. So before your organization gives another agent production write access, ask three questions:</p>
<ol>
<li><strong>What outcome can it never cause?</strong></li>
<li><strong>Who can stop it when the platform is down?</strong></li>
<li><strong>What record will prove both?</strong></li>
</ol>
<p>If you can't answer all three with evidence, that's your roadmap for 2027.</p>
<p><em>Fellow CAIOs, CTOs, CIOs and CDOs: which of those three questions is hardest to answer in your organization today? Tell me in the comments.</em></p>
<hr />
<h2>Glossary</h2>
<ul>
<li><strong>Rogue AI agent:</strong> an autonomous AI agent that causes harm while holding valid credentials, whether manipulated or through the combined effect of several authorized agents.</li>
<li><strong>Autonomy debt:</strong> the gap between the authority an enterprise delegates to AI agents and the control it can prove over them.</li>
<li><strong>Action gateway:</strong> a deterministic enforcement point between an agent's proposed action and the system it would change.</li>
<li><strong>Business-state rule:</strong> a policy that evaluates the resulting business outcome (for example, "no payment to a bank account changed in the last 30 days without call-back verification"), not just whether a single call was permitted.</li>
<li><strong>Policy-as-code:</strong> business and security rules written in a machine-enforceable, versioned language (such as Cedar or OPA/Rego) that sits outside the model.</li>
<li><strong>Lethal trifecta:</strong> private data + untrusted content + external communication in one agent session.</li>
<li><strong>Mean time to provenance (MTTP):</strong> the time needed to reconstruct the full chain behind a disputed agent action, from initiator to receipt.</li>
<li><strong>Guardian agent:</strong> an independent agent that monitors other agents; deterministic where it decides, model-based only where it advises.</li>
</ul>
<hr />
<h2>Frequently asked questions</h2>
<p><strong>What is a rogue AI agent?</strong> A rogue AI agent is an autonomous AI agent that causes harm while using valid enterprise credentials. It can be manipulated by malicious content or tools. More often, it is one of several authorized agents whose individually correct actions combine into an outcome nobody approved, such as a fraudulent payment.</p>
<p><strong>Why can't traditional security tools stop rogue AI agents?</strong> Most security tools check whether a single identity or a single call is permitted. Rogue-agent incidents usually involve valid identities and permitted calls. Stopping them requires business-state rules that evaluate the resulting outcome, enforced by an independent action gateway outside the model.</p>
<p><strong>What is the best architecture for governing agentic AI?</strong> The model proposes and an independent action gateway decides. Business-state rules are enforced as policy-as-code. Approvals bind to a fingerprint of the exact action. Limits are cumulative across agents. A kill switch revokes tokens, gateway access, queued work and egress from outside the agent platform.</p>
<p><strong>What should a CAIO or CTO do in the next 90 days?</strong> Create an agent registry with a named owner for every agent. Give every agent with production write access a scoped mandate, a hard limit on harm and a tested revocation path. Run a game day that takes down the identity provider and gateway. Start measuring mean time to provenance.</p>
<p><strong>Which industries are most exposed to rogue AI agents?</strong> Banks, insurers, manufacturers, utilities and government agencies that are adopting AI agents quickly on top of legacy core systems such as core banking, ERP, MES and SCADA.</p>
<p><strong>How do regulations like SR 26-2, DORA and the EU AI Act affect AI agents?</strong> SR 26-2 replaced US model-risk guidance in April 2026 but leaves generative and agentic AI outside its scope for now, so examiners rely on operational-resilience, third-party-risk and internal-control expectations. DORA already applies in Europe, and the EU AI Act's high-risk obligations begin in December 2027. In every case, firms will be judged on evidence of control.</p>
<hr />
<h2>About the author</h2>
<img src="https://cdn.hashnode.com/uploads/covers/6aff50a9bfa6af59fb6e4e7d/f7d08701-d810-4003-b7c4-594d00357f5c.jpg" alt="" style="display:block;margin:0 auto" />

<p><strong>Ganesh Raju</strong> is the Chief AI &amp; Innovation Officer (CAIO) and CTO at <a href="https://www.elixirglobal.com"><strong>Elixir Global</strong></a>, an AI-first enterprise consulting firm headquartered in Atlanta with offices in Houston, Dubai, Bengaluru and Singapore. He leads enterprise AI strategy and owns the company's AI product portfolio, including <strong>AgentVault</strong>, Elixir's library of production-ready, governed AI agents for SAP and enterprise operations. He helps global enterprises in energy, oil and gas, manufacturing, healthcare and life sciences, financial services and the public sector move agentic AI from pilots into governed, auditable production.</p>
<p><strong>Data, machine learning and AI:</strong> Ganesh has more than 15 years of experience in artificial intelligence, machine learning and data engineering. As Head of Big Data, Data Science &amp; AI at Linaro, he led Arm enablement of the open-source big data and data science ecosystem. He served as an ODPi PMC member and TSC lead and as a Linux Foundation TSC member, and he led the Apache Bigtop community. An open-source committer, he has contributed to projects including TensorFlow, Apache Spark and Hadoop, and holds certifications from Cloudera, Cassandra and Anthropic (Claude).</p>
<p><strong>Author and speaker:</strong> He is the author of <em>AI Blockchain Design and Deployment</em> (BPB Publishing). He has published technical papers and speaks at AI and industry conferences on agentic AI, AI governance, the autonomous enterprise, digital twins and physical AI.</p>
<p><strong>Entrepreneur, investor, advisor and mentor:</strong> Ganesh is the founder and CEO of <a href="http://Akshaya.io"><strong>Akshaya.io</strong></a> (founded 2019) and the founder of <strong>RapidEVChargE</strong> (rapidevcharge.com), an EV-charging infrastructure company serving India and the Americas. He is an investor, a mentor to founders and technology leaders, and an advisor to <strong>Canon</strong>.</p>
<p><strong>Community:</strong> He is a former Vice Chair of <strong>IEEE Houston</strong> and a member of Cohort 21 of the <strong>Wharton Executive Education Chief Technology Officer program</strong>. He has lived in Houston, Texas, for 29 years.</p>
<p>Connect with Ganesh on <a href="https://www.linkedin.com/in/ganeshraju07">LinkedIn</a> and <a href="https://github.com/ganeshraju">GitHub</a>.</p>
<p><em>This article expands on a version first published on</em> <a href="https://www.linkedin.com/pulse/rogue-agent-have-valid-credentials-ganesh-raju-wg51c/"><em>LinkedIn</em></a><em>.</em></p>
<p>#AgenticAI #AIGovernance #RogueAgents #AISecurity #EnterpriseAI #CAIO #CTO #AIAgents #CyberSecurity #RiskManagement #DigitalTwin #SAP #ElixirGlobal</p>
]]></content:encoded></item></channel></rss>