<?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" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Venkata Phani Patelkhana on Medium]]></title>
        <description><![CDATA[Stories by Venkata Phani Patelkhana on Medium]]></description>
        <link>https://medium.com/@venkataphanipatelkhana?source=rss-3f4e599fa0ff------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*MvqGmYDeas1TxYLi</url>
            <title>Stories by Venkata Phani Patelkhana on Medium</title>
            <link>https://medium.com/@venkataphanipatelkhana?source=rss-3f4e599fa0ff------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:04:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@venkataphanipatelkhana/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your AI Agent Can Reach the Data. Can It Follow the Meaning?]]></title>
            <link>https://venkataphanipatelkhana.medium.com/your-ai-agent-can-reach-the-data-can-it-follow-the-meaning-8a3606a611f5?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a3606a611f5</guid>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[data-governance]]></category>
            <category><![CDATA[semantic-layer]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sun, 15 Nov 2026 18:02:12 GMT</pubDate>
            <atom:updated>2026-11-15T18:22:27.356Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Why enterprise answers need connected business context, reliable data, and consistent interpretation — not just warehouse access.</em></h4><p><em>Disclaimer: The opinions expressed in this article are solely my own and do not represent the views or positions of my employer.</em></p><h3>TL;DR</h3><p>An AI agent can access the right data, execute valid SQL, and still answer the wrong business question.</p><p>Trustworthy analytical answers require three connected checks:</p><ul><li>Interpretation: Does the selected business meaning match the question?</li><li>Implementation: Does the calculation follow that meaning?</li><li>Readiness: Is the selected data sufficiently fresh, complete, validated, and approved for the intended use?</li></ul><p>Enterprises already have many building blocks — glossaries, semantic models, data contracts, and observability. The challenge is ensuring that the relevant context and evidence actually influence the agent’s decisions across tools.</p><p>Data access is only the beginning. The answer should make clear what was calculated, which data was used, and what limitations apply.</p><p>Let me paint a scenario</p><p>A business user opens an AI assistant and asks:</p><blockquote><strong><em>“How many active customers did we have last quarter?”</em></strong></blockquote><p>The agent connects to the warehouse, finds a customer table, generates SQL, and returns a number. The query executes successfully. The response includes a source.</p><p>But what did “active” mean? Which reporting calendar applied? Did the calculation count customers who purchased during the quarter, or customers classified as active on its final day?</p><p>Warehouse access does not resolve those questions.</p><h3>Why This Matters</h3><p>A query can run, cite a source, and still answer a different question from the one the user intended.</p><p>That number could reach a board presentation, a forecast, or a budget decision before anyone notices that a different definition was used.</p><p>An organization may already have many of the ingredients: business glossaries, semantic models, data contracts, and quality checks. The question is whether the relevant information reaches the components producing the answer.</p><p>To answer well, the agent needs to connect the business request to an applicable definition, a suitable calculation, and the data that implements it. It also needs to account for whether that data is ready for the intended use.</p><p><strong>The architectural challenge is not simply making enterprise data reachable. It is preserving meaning as a question moves across definitions, models, data products, and execution tools.</strong></p><h3>Business Meaning Was Already Part of Analytics</h3><p>For years, enterprise analytics followed a familiar path:</p><pre>Operational systems<br>        ↓<br>Data pipelines<br>        ↓<br>Warehouse or lakehouse<br>        ↓<br>Semantic model<br>        ↓<br>Reports and dashboards</pre><p>The destination was often a report designed to answer a known set of questions.</p><p>Report authors made decisions about customer populations, transaction eligibility, relationships, filters, calculations, and reporting periods. Semantic models captured many of those decisions for reuse.</p><p>A semantic model provides a business-facing representation of data through measures, dimensions, relationships, and calculations. Those investments remain relevant: Power BI semantic models, for example, can serve as sources for Microsoft Fabric data agents.</p><p>Business meaning is not new to AI. What changes with an open-ended assistant is where some interpretation happens.</p><p>In a predefined report, the author has already settled much of what a calculation means. The user may select a quarter, but the underlying definition is usually established.</p><p>With an agent, some choices remain unresolved until the question arrives.</p><p>The agent needs more than a view of the schema. It needs a way to discover which business meaning applies and how that meaning connects to an executable calculation.</p><h3>From Predefined Reports to Open-Ended Questions</h3><p>Traditional analytics and agentic AI are not competing approaches. They can use the same semantic models, business definitions, and governed datasets.</p><p>The difference is how those capabilities are applied.</p><p>In a predefined reporting workflowIn an open-ended agent workflowReports are designed around anticipated questionsUsers may ask questions not anticipated during report designMuch of the interpretation is settled during developmentSome interpretation must be resolved when the question arrivesCurated reports reuse established calculationsAgents may select metrics or construct queries dynamicallyUsers navigate dashboards and reporting structuresUsers explore through natural languageReporting processes establish expectations for data readinessReadiness may need to be assessed for the particular answer</p><p>These are patterns, not absolute boundaries. A dashboard can contain incorrect logic. An agent can correctly execute an approved metric.</p><p>The opportunity is to reuse established analytics investments without losing their meaning when questions become more flexible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*td0gK9ue4c3LtZ7udE42zg.png" /></figure><h3>One Phrase Can Hide Several Questions</h3><p>Return to the retailer’s request:</p><blockquote><strong><em>“How many active customers did we have last quarter?”</em></strong></blockquote><p>“Active customers” might mean:</p><ul><li>Customers who made a qualifying purchase during the quarter.</li><li>Customers classified as active at quarter-end under a rolling purchase window.</li><li>Customers who interacted through an application, email, or loyalty program.</li></ul><p>These are illustrative definitions. Each could be useful, but they answer different questions.</p><p>Even “last quarter” needs context.</p><p>Does it mean the previous calendar quarter or the retailer’s fiscal quarter? Is the user asking for a finalized reporting figure or the latest available estimate?</p><p>The agent should not have to invent these conventions.</p><h3>What the Difference Looks Like</h3><p>Consider two simplified queries.</p><p>Assume both datasets use the same customer population and purchase-qualification rules. order_date is a business-date field, and the activity dataset contains one row per customer per snapshot date.</p><p><strong>Reading A: Customers who purchased during the quarter</strong></p><pre>SELECT COUNT(DISTINCT customer_id)<br>FROM orders<br>WHERE is_qualifying_order = TRUE<br>  AND order_date &gt;= DATE &#39;2026-07-01&#39;<br>  AND order_date &lt;  DATE &#39;2026-10-01&#39;;</pre><p><strong>Reading B: Customers classified as active at quarter-end</strong></p><pre>SELECT COUNT(*)<br>FROM customer_activity_daily<br>WHERE snapshot_date = DATE &#39;2026-09-30&#39;<br>  AND is_active_customer = TRUE;</pre><p><em>Illustrative SQL; syntax may vary by platform.</em></p><p>Suppose the activity flag uses an inclusive 90-day purchase window ending on the snapshot date.</p><p>For September 30, that window begins on July 3. A customer whose only qualifying purchase occurred on July 1 belongs to the quarterly purchasing population, but not to the rolling active population at quarter-end.</p><p>ReadingWhat it measuresIllustrative resultPurchased during the quarterDistinct customers with qualifying purchases during Q352,300Active at quarter-endCustomers meeting the rolling activity definition on September 3041,200</p><p><em>The numbers are invented to illustrate the distinction.</em></p><p>Both queries can correctly implement their respective definitions. That does not establish which definition the requester intended.</p><p>Where an established metric or workflow resolves the question, that context should be available.</p><p>Where material ambiguity remains, the agent may need to ask:</p><blockquote><strong><em>“Do you mean customers who purchased during the quarter, or customers classified as active at quarter-end?”</em></strong></blockquote><p>That is not a failure to answer. It is a step toward answering the intended question.</p><h3>Three Checks Behind a Useful Answer</h3><p>It helps to separate three questions that can otherwise blur together.</p><p>CheckCore question<strong>Interpretation</strong>Are we answering the intended business question?<strong>Implementation</strong>Does the calculation follow the selected meaning?<strong>Readiness</strong>Are the inputs suitable for the intended use?</p><p>A system can satisfy one and fail another.</p><p>It might select the right definition but use the wrong calculation.</p><p>It might calculate correctly while answering the wrong interpretation.</p><p>Or it might do both correctly using an incomplete reporting snapshot.</p><p>Authorization is a separate boundary: it determines whether the requester may perform the operation. Permission to execute does not establish that the interpretation, calculation, or inputs are appropriate.</p><p>A successful query can make all of these questions look settled when they are not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3SRjIZzu1AaBXsGfwYXmQ.png" /></figure><h3>Think About Responsibilities, Not a Shopping List</h3><p>The discussion can quickly become a list of tools: glossary, taxonomy, ontology, semantic layer, catalog, and observability platform.</p><p>A more useful starting point is the responsibility each supports.</p><p>ResponsibilityQuestion it helps answerBusiness terminologyWhat does this term mean in this context?Classification and conceptual relationshipsHow is this concept organized and related to others?Semantic modelingWhich metrics, dimensions, relationships, and calculations are available?Data products and contractsWhat is published, who owns it, and what expectations apply?Semantic mappings and contractsHow do definitions connect to approved calculations and data representations?Data-readiness evidenceIs the selected data suitable for the intended use?</p><p>These responsibilities can overlap, and several may be supported by one platform.</p><p>A glossary might distinguish an organization-wide definition of Customer from a domain-specific definition of Active Customer.</p><p>An ontology might describe relationships among customers, accounts, orders, and purchases.</p><p>A semantic model might define the calculations used to report customer activity.</p><p>Not every use case needs every artifact. Not every responsibility needs a separate repository.</p><p>The important requirement is that the necessary connections exist — and reach the components making the decisions.</p><h3>Business Meaning Must Reach the Fields and Calculations</h3><p>A glossary entry can define Active Customer. But the calculation still needs to know where the relevant information is represented.</p><p>Consider the retailer’s daily customer-activity dataset:</p><p>Business meaningPhysical representationCustomer identitycustomer_activity_daily.customer_idActivity evaluation datecustomer_activity_daily.snapshot_dateMost recent qualifying purchasecustomer_activity_daily.last_qualifying_order_dateEvaluated activity statuscustomer_activity_daily.is_active_customer</p><p>These mappings make the definition usable beyond the glossary.</p><p>But a term-to-column link is not always enough.</p><p>“Customers who purchased during the quarter” may require identifiers, purchase dates, qualifying-transaction rules, joins, and a distinct count. Its meaning is represented by a calculation over data, not necessarily by one stored field.</p><p>A useful distinction is:</p><p><strong>A reference identifies where meaning is defined. A mapping describes how a particular data representation is intended to implement it.</strong></p><p>A reference to Customer does not establish whether an identifier represents a person, an account, or a loyalty membership. The mapping needs to make that scope clear.</p><p>Likewise, a reference to Active Customer does not explain the window, cutoff, or qualifying events a particular calculation uses.</p><p>A semantic contract can establish a broader agreement about business meaning and implementation.</p><p>For example, it may identify the approved metric, its business definition, grain, reporting context, calculation rules, and relationships to published data products.</p><p>Such an agreement does not necessarily require another independent document or platform. It may be represented through governed metadata, semantic models, or explicit contract artifacts.</p><p>An agent may receive these details through a governed semantic model rather than inspect physical columns directly.</p><p>Either way, the path from business meaning to implementation should remain traceable.</p><h3>Follow the Meaning, Not Just the Records</h3><p>A data-flow diagram explains where records move.</p><p>For an agent-generated answer, we also need to understand how meaning connects to the calculation:</p><pre>Business question<br>        ↓<br>Applicable definition and reporting context<br>        ↓<br>Suitable metric and calculation rules<br>        ↓<br>Semantic model or explicit mappings<br>        ↓<br>Published data interface<br>        ↓<br>Executed calculation<br>        ↓<br>Answer with its interpretation</pre><p>This is a traceability model, not a required runtime sequence or technology stack.</p><p>An agent might call a governed metric directly, use a semantic model to generate a query, or require explicit mappings to published tables.</p><p>The implementation can vary. The questions remain:</p><ul><li>Which definition was selected, and why did it apply?</li><li>Which population, calendar, and period were used?</li><li>How was the definition implemented?</li><li>Did the executed calculation follow that definition?</li><li>Does the explanation describe what actually ran?</li></ul><p>A citation to a source table does not answer all of these questions.</p><p>An agent may retrieve the approved definition of Active Customer and still generate SQL using a similarly named column with different semantics.</p><p>Discovery makes the meaning available. Execution must preserve it.</p><p>There is also an important difference between traceability and validation.</p><p><strong>Traceability explains how an answer was produced. Validation asks whether the selected interpretation and executed calculation were appropriate for the question.</strong></p><p>A complete trace can explain a wrong answer just as clearly as a correct one.</p><p>This is why connecting an agent to a catalog or knowledge graph does not, by itself, establish that its calculations are correct.</p><p>Discovering a definition and applying it in an executable calculation are related but separate responsibilities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YOkSZ7DnS3dKQWJv4GPP7Q.png" /></figure><h3>Where Data Contracts Help</h3><p>Bitol’s Open Data Contract Standard, ODCS v3.2.0, provides building blocks for connecting published data with business context.</p><p>Its schema supports objects and properties, with metadata such as business names, descriptions, transformation details, and quality expectations. Authoritative-definition references can connect contract elements to external sources of meaning.</p><p>Version 3.2.0 also includes capabilities relevant to semantic interoperability:</p><ul><li>An optional semanticType distinguishes columns, measures, and dimensions, with measure aggregation expressions represented through transformLogic.</li><li>Recommended authoritative-definition types include glossary, ontology, and taxonomy.</li><li>Synonyms provide alternative names for schema objects and properties.</li><li>An optional context block carries instructions, verified statements, and constraints.</li></ul><p>These capabilities help a published interface communicate more than its physical structure.</p><p>But identifying a property as a measure does not establish that it represents the right interpretation for a user’s question.</p><p>Documenting a calculation does not establish that a consuming application selected and executed it correctly.</p><p>These connections may be maintained in semantic models, data contracts, metadata services, or an explicit semantic agreement — sometimes called a semantic contract.</p><p>Here, that term describes an architectural idea, not a separate Bitol standard.</p><p>What matters is traceability between the definition, the calculation, and the data representation — not another mandatory file.</p><h3>Context Must Survive Product Boundaries</h3><p>In an enterprise, relevant information is often distributed.</p><p>Business terminology may live in a governance platform.</p><p>Metrics may live in a semantic-modeling tool.</p><p>Contracts may be maintained in version control.</p><p>Pipeline evidence may live in an observability system.</p><p>The agent may run elsewhere.</p><p>This creates an important distinction:</p><blockquote><strong><em>“We have that information” is not the same as “the answering process used that information.”</em></strong></blockquote><p>Even integrated products have context boundaries.</p><p>Microsoft’s Fabric documentation provides a concrete example: the DAX generation tool for Power BI semantic models ignores instructions added at the data-agent level and relies on semantic-model metadata and Prep for AI configuration. Guidance that must influence that generation step should therefore be configured in the model’s Prep for AI settings, rather than only in general agent instructions.</p><p>Microsoft’s ontology documentation describes a related limitation: some ontology context might not be used during query generation when a Power BI semantic model is the underlying source. The integration is documented as a preview feature.</p><p>The lesson is not that integration is ineffective. It is that the actual execution path matters.</p><p>When evaluating an integration, ask:</p><ul><li>Which definitions influence metric selection?</li><li>Which mappings reach query generation?</li><li>Which instructions apply to the selected source?</li><li>Which constraints are advisory, and which are enforced?</li><li>Which assumptions appear in the final explanation?</li></ul><p>Context that never reaches the relevant decision cannot guide it.</p><p>And an instruction is not necessarily an enforced rule.</p><h3>Correct Meaning Still Needs Suitable Data</h3><p>Suppose the agent selects the correct quarterly purchasing metric and applies the approved calculation.</p><p>The underlying dataset may still be incomplete.</p><p>Imagine the pipeline completed its scheduled run, but one region has not delivered its final transactions.</p><p>The query can produce a reasonable number without representing the retailer’s finalized quarterly population.</p><p>A preliminary operational estimate and a finalized financial figure may have different requirements.</p><p>The answering process therefore needs relevant evidence about the selected data — not merely a generic “healthy” status.</p><p>EvidenceWhat it can help establish<strong>Freshness</strong>Whether the relevant data is current enough<strong>Completeness</strong>Whether expected deliveries, records, or partitions are present<strong>Validation and reconciliation</strong>Whether specified checks passed<strong>Lineage</strong>Which sources and transformations contributed<strong>Pipeline status</strong>Whether relevant processing completed or encountered failures<strong>Reporting status</strong>Whether the snapshot is approved for the intended purpose</p><p>These signals are not interchangeable.</p><p>Fresh data can be incomplete.</p><p>A completed pipeline can contain failed business checks.</p><p>A snapshot can pass automated validation without being approved for final reporting.</p><p>A passed check supports only the properties it actually tests.</p><p>There is another important detail: <strong>readiness evidence must correspond to the data actually used in the calculation.</strong></p><p>A quality dashboard may report that a dataset is healthy today. But the agent’s calculation may use an earlier snapshot, a different partition, or data assembled from multiple products.</p><p>For readiness information to be useful, it should be associated with the relevant dataset version, reporting period, partition, or snapshot.</p><p>Otherwise, the agent may receive a current quality status that does not describe the data behind its answer.</p><p>The language model does not need to interpret raw monitoring events itself. The platform can expose curated readiness information through catalogs, observability services, or governed metadata interfaces.</p><p>But the answering process should receive enough evidence to identify material limitations.</p><p>And when required readiness conditions are not met, it should follow the applicable business and reporting policy.</p><p>That may mean qualifying the result as preliminary, using an approved snapshot, requesting clarification, or withholding a definitive answer.</p><p><strong>Pipeline evidence describes what happened. Readiness assessment determines whether that condition is acceptable for the requested answer.</strong></p><p>The two should be connected, but they are not the same thing.</p><h3>Different Words Should Not Quietly Change the Meaning</h3><p>Once the intended question is clear, consistency provides another useful check.</p><p>Consider:</p><blockquote><strong><em>“How many distinct registered customers purchased during Q3?”</em></strong></blockquote><p>And:</p><blockquote><strong><em>“What was the number of unique registered purchasers in Q3?”</em></strong></blockquote><p>If both resolve to the same metric, population, period, calculation rules, permissions, and data snapshot, they should produce equivalent business results.</p><p>The explanation does not need to be identical. Language-model output can vary even when the prompt is unchanged.</p><p>But different wording should not silently select a different business interpretation.</p><p>Before treating a difference as a defect, check whether the conditions really were the same.</p><p>Data, permissions, definitions, reporting periods, or conversation context may have changed.</p><p>When those conditions are controlled, an unexplained difference is a reason to trace where the paths diverged.</p><p>This suggests a practical evaluation exercise: try several equivalent phrasings and compare the selected metric, calculation, reporting context, and result — not just the final wording.</p><p>Consistency does not prove correctness. A system can repeat the same mistake.</p><p>It is one useful check alongside interpretation, implementation, and readiness.</p><h3>Make the Interpretation Visible</h3><p>The user should not need to inspect SQL to discover what an answer means.</p><p>Compare two illustrative responses.</p><p><strong>Response A:</strong></p><blockquote><em>“You had 52,300 active customers last quarter.”</em></blockquote><p><strong>Response B:</strong></p><blockquote><em>“52,300 distinct registered customers made a qualifying purchase during the calendar quarter. This is not the rolling active population at quarter-end. The figure is preliminary because one region’s final transactions have not completed reconciliation.”</em></blockquote><p>The additional detail is purposeful.</p><p>It states what was counted and what could change the result.</p><p>The explanation does not need to expose every internal artifact. It should surface assumptions and limitations that could materially change how the result is used.</p><p>Behind that explanation, the system should be able to identify the selected metric, applicable definition, calculation, data snapshot, and relevant readiness evidence.</p><p>That does not guarantee correctness.</p><p>It makes the answer easier to inspect, challenge, and correct.</p><h3>What to Ask Your Team</h3><p>Start with one high-value business question rather than another platform.</p><p>For “active customers last quarter,” identify the plausible interpretations. Find the approved definitions. Follow them to the metrics, calculations, mappings, and published data interfaces.</p><p>Then examine what the answering process actually uses.</p><h3>For business leaders</h3><ul><li>Can the assistant explain which definition and reporting period it used?</li><li>Does it clarify material ambiguity rather than quietly choose an interpretation?</li><li>Can it distinguish a final figure from a preliminary or incomplete result?</li><li>Do equivalent questions produce equivalent business results under the same conditions?</li><li>Who owns the definition, and who is responsible when the answer is challenged?</li></ul><h3>For engineers and architects</h3><ul><li>Can you trace the selected metric from its business definition to the executed calculation?</li><li>Are customer scope, time rules, eligibility filters, joins, and aggregation behavior explicit?</li><li>Which definitions and instructions actually reach query generation for each source type?</li><li>Can quality and pipeline evidence be associated with the dataset version or snapshot actually used?</li><li>What happens when required readiness conditions are not met?</li><li>Do tests compare resolved metrics and calculations, rather than only plausible final numbers?</li><li>Does the explanation match what actually ran?</li></ul><p>This exercise may reveal a missing capability.</p><p>It may also reveal that the necessary capabilities already exist, but their connections are incomplete.</p><h3>The Goal Is Continuity of Meaning</h3><p>The warehouse is not going away. Neither are pipelines, semantic models, glossaries, contracts, or reports.</p><p>Agents add another way to use those investments — and another place where interpretation can go wrong.</p><p>An agent does not need every enterprise definition copied into its prompt.</p><p>It needs a reliable path to discover the applicable meaning, resolve that meaning to a suitable calculation, and obtain relevant evidence about the data used.</p><blockquote><strong>Access</strong> tells the agent what it can reach.</blockquote><blockquote><strong>Connected business context</strong> helps it determine what to calculate.</blockquote><blockquote><strong>Execution checks</strong> help establish whether the calculation follows that meaning.</blockquote><blockquote><strong>Readiness evidence</strong> helps determine whether the inputs are suitable for the requested use.</blockquote><p>The enterprise challenge is making those responsibilities work together when the answer is produced — not merely having them somewhere in the platform.</p><p>An agent that can reach the data has access.</p><p>An agent that can follow its business meaning has a better basis for answering the intended question.</p><p>And an agent that can connect the answer to its calculation and data-readiness evidence gives business users a better basis for deciding whether to trust it.</p><h3>References</h3><ol><li>Microsoft Learn. <a href="https://learn.microsoft.com/en-us/fabric/data-science/semantic-model-best-practices">Semantic model best practices for Fabric data agents</a>.</li><li>Microsoft Learn. <a href="https://learn.microsoft.com/en-us/fabric/data-science/data-agent-ontology-sources">Use Ontology as context in Fabric data agent</a>.</li><li>Bitol. <a href="https://bitol-io.github.io/open-data-contract-standard/v3.2.0/changelog/">Open Data Contract Standard, Version 3.2.0</a>.</li><li>OpenMetadata. <a href="https://docs.open-metadata.org/v1.12.x/how-to-guides/data-quality-observability/quality">Data Quality and Observability</a>.</li></ol><p><em>Next in this series: </em><strong><em>“The Data Contract Passed. The Business Answer Was Still Wrong.”</em></strong><em> A closer look at the checks needed when several valid metrics could answer the same business phrase.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a3606a611f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Built the Map. Now What Should Live on It?]]></title>
            <link>https://venkataphanipatelkhana.medium.com/we-built-the-map-now-what-should-live-on-it-df03c2835aa8?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/df03c2835aa8</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[knowledge-graph]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-governance]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 03:19:50 GMT</pubDate>
            <atom:updated>2026-09-24T03:21:40.919Z</atom:updated>
            <content:encoded><![CDATA[<h4>Materialize Knowledge. Resolve State. Assemble Context. Preserve Evidence.</h4><p><em>Disclaimer: The opinions expressed in this article are solely my own and do not represent the views or positions of my employer.</em></p><p>In my previous article, <strong>“From Data Products to Context Graphs: Building the Map AI Agents Need,”</strong> I described a progression that I believe enterprises will increasingly need as AI agents become part of real business operations:</p><p><strong>Data Products → Vocabulary → Taxonomy → Ontology → Knowledge Graph → Context Graph</strong></p><p>The idea was simple.</p><p>Before an AI agent can navigate an enterprise, the enterprise itself has to become understandable.</p><p>Data needs clear ownership. Terms need consistent meaning. Customers, products, accounts, systems, policies, people, and processes need to be connected.</p><p>That gives the agent a map.</p><p>But once we build that map, another practical question appears:</p><blockquote><strong><em>What should actually live inside it?</em></strong></blockquote><p>Should every account balance be copied into the graph?</p><p>Should current inventory be continuously synchronized?</p><p>Should order status, permissions, risk scores, and every other changing value live there too?</p><p>Or should the graph tell the agent where those facts can be found and let the agent retrieve them when they matter?</p><p>The more I think about this, the more I come back to four ideas:</p><blockquote><strong><em>Materialize knowledge.<br>Resolve state.<br>Assemble context.<br>Preserve evidence.</em></strong></blockquote><p>In simpler terms:</p><blockquote><strong><em>Remember what is stable. Look up what can change. Bring together only what matters. Keep enough evidence to explain the action.</em></strong></blockquote><p>That distinction becomes especially important when AI agents do more than answer questions.</p><p>They act.</p><h3>Think About a City Map</h3><p>Let me continue the city analogy from the previous article.</p><p>When I open a navigation app, it already knows a lot about the city.</p><p>It knows which roads connect, where the intersections are, and where hospitals, schools, airports, and neighborhoods are located.</p><p>That structure does not need to be rediscovered every time I start a trip.</p><p>It is stored knowledge.</p><p>But the map cannot permanently contain everything happening in the city.</p><p>Traffic changes.</p><p>An accident happens.</p><p>A road closes.</p><p>Construction blocks a lane.</p><p>Those conditions need to come from current sources.</p><p>That is <strong>state</strong>.</p><p>And there is one more thing the map cannot know until I tell it:</p><p><strong>my journey.</strong></p><p>Where am I starting?</p><p>Where am I going?</p><p>Am I driving or walking?</p><p>Do I want to avoid toll roads?</p><p>The route I receive is not simply stored in the map, and it is not just live traffic either.</p><p>It is assembled from:</p><p><strong>the map + current conditions + my destination + my constraints</strong></p><p>That is <strong>context</strong>.</p><p>And after the trip, if something went wrong, I may want to know which route was chosen, what conditions influenced it, and why.</p><p>That is <strong>evidence</strong>.</p><p>Enterprise AI agents face almost exactly the same problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zr4b-hLv7mg8Ge8Tz3ezvw.png" /></figure><h3>The Knowledge Graph Is the Map</h3><p>A knowledge graph gives us a connected view of how things in the enterprise relate to one another.</p><p>For example:</p><pre>Customer → owns → Account<br>Customer → places → Order<br>Order → contains → Product<br>Order → paid through → Payment<br>Product → supplied by → Supplier<br>Refund → governed by → Refund Policy</pre><p>These relationships are useful far beyond one transaction.</p><p>They help the agent understand how the business works:</p><ul><li>what is connected to what</li><li>who owns what</li><li>which policy applies</li><li>which system is responsible</li><li>where to look next</li></ul><p>That is exactly the kind of knowledge worth materializing.</p><p>And a knowledge graph can contain specific facts too:</p><pre>Customer 18472 → placed → Order 984721</pre><p>There may be very good reasons to store that relationship.</p><p>So the real question is not whether specific facts belong in a graph.</p><p>It is this:</p><blockquote><strong><em>Does every changing fact need to be copied into the graph before the agent needs it?</em></strong></blockquote><p>That is where the design gets interesting.</p><h3>The Graph Does Not Need to Become the Enterprise</h3><p>Suppose a customer says:</p><blockquote><strong><em>“My order arrived damaged. Can you refund it?”</em></strong></blockquote><p>The agent needs some basic knowledge.</p><p>It needs to understand how customers relate to orders, how orders relate to payments, which refund policy applies, which system handles the payment, and what approval is required.</p><p>That is enterprise knowledge.</p><p>But the agent also needs answers to a different set of questions:</p><ul><li>Has this order actually been delivered?</li><li>Has it already been refunded?</li><li>How much did the customer pay?</li><li>Is there a fraud hold?</li><li>Is the refund window still open?</li><li>Is this agent allowed to issue the refund right now?</li></ul><p>These facts are different.</p><p>They can change.</p><p>And <strong>when</strong> we ask matters.</p><p>Imagine the graph says:</p><pre>Payment status = Settled</pre><p>but the payment system reversed the transaction five seconds ago.</p><p>The graph may still look perfectly connected.</p><p>The answer may still sound convincing.</p><p>But it is based on old information.</p><p>For a report, stale data may mean someone sees yesterday’s number.</p><p>For an AI agent that can act, stale data may lead to the wrong action.</p><p>That changes the design.</p><h3>Store Enough to Navigate</h3><p>Instead of trying to copy everything, the graph can tell the agent where important information belongs.</p><p>For example:</p><pre>Order<br>   → payment handled by<br>Payment System</pre><pre>Payment System<br>   → current status available from<br>Payment Lookup Service</pre><pre>Refund<br>   → performed through<br>Refund Service</pre><pre>Refund<br>   → governed by<br>Refund Policy RP-17</pre><p>That is extremely useful.</p><p>The agent now understands:</p><p><strong>what things mean</strong></p><p><strong>how they relate</strong></p><p><strong>which system owns them</strong></p><p><strong>where to go for the current answer</strong></p><p>What the graph does not necessarily need is every current value:</p><pre>payment_status = settled<br>refund_status  = none<br>fraud_hold     = false<br>amount         = $184.42</pre><p>When those facts matter, the agent can retrieve them from the system responsible for them.</p><p>That leads to a principle I keep coming back to:</p><blockquote><strong><em>The map should tell the agent where the truth lives. It does not always need to contain a copy of the truth.</em></strong></blockquote><h3>Resolve State When It Matters</h3><p>I originally thought about this as the familiar technology debate:</p><blockquote><strong><em>Should we copy the data, or leave it where it is?</em></strong></blockquote><p>But <strong>resolve state</strong> describes the agent problem more clearly.</p><p>Current information may come from many places:</p><ul><li>an application</li><li>a database</li><li>an API</li><li>an event stream</li><li>an identity system</li><li>a policy service</li><li>another governed enterprise service</li></ul><p>The mechanism matters less than the principle:</p><blockquote><strong><em>If a fact changes often and an agent’s action depends on it being current, retrieve it from the system responsible for it close enough to the time of the decision.</em></strong></blockquote><p>That does not mean we never cache information.</p><p>Of course we will.</p><p>It does not mean current values can never appear in a graph.</p><p>They can.</p><p>Real systems always balance speed, reliability, availability, cost, and consistency.</p><p>The important distinction is between:</p><blockquote><strong><em>knowledge about how the enterprise works</em></strong></blockquote><p>and</p><blockquote><strong><em>facts about what is happening right now</em></strong></blockquote><p>An agent may need both.</p><p>It does not always need both stored in the same place.</p><h3>Context Is the Route Through the Map</h3><p>The term <strong>context graph</strong> is still evolving, so let me be clear about how I use it here.</p><p>I mean the small, connected view of information an agent needs for a particular task.</p><p>That may include:</p><ul><li>relevant knowledge</li><li>important relationships</li><li>current facts</li><li>identity</li><li>authority</li><li>constraints</li><li>the task itself</li><li>where important information came from</li></ul><p>Return to our refund example.</p><p>The enterprise may know about millions of customers, products, transactions, and systems.</p><p>This customer may have hundreds of previous orders.</p><p>The organization may have thousands of policies.</p><p>The agent needs almost none of that.</p><p>For this decision, it may need something closer to:</p><pre>WHO<br>Customer 18472</pre><pre>TASK<br>Refund damaged order 984721</pre><pre>RELATIONSHIPS<br>Customer 18472 → owns → Order 984721<br>Order 984721 → paid through → Payment PMT-55190</pre><pre>POLICY<br>Damaged items qualify for refund under Policy RP-17</pre><pre>CURRENT FACTS<br>Order delivered<br>Payment settled<br>No previous refund<br>No fraud hold<br>Order value: $184.42</pre><pre>AUTHORITY<br>This agent may issue refunds up to $250</pre><pre>PROPOSED ACTION<br>Refund Payment PMT-55190</pre><p>Some of this information was stored ahead of time.</p><p>Some was retrieved in the moment.</p><p>Some came from an authorization system.</p><p>Those pieces do not need to live permanently in one graph or database.</p><p>What matters is that the right information comes together for the task.</p><h3>Where Facts Come From Matters</h3><p>One more thing should stay attached to important facts:</p><p><strong>where they came from.</strong></p><p>Consider:</p><pre>Payment status = Settled</pre><p>That statement means something very different if it came from:</p><ul><li>the payment system five seconds ago</li><li>a cache refreshed an hour ago</li><li>a previous conversation</li><li>something the model inferred</li></ul><p>Those are not equivalent.</p><p>The agent needs the right information.</p><p>But it also needs enough information about the source to use that fact responsibly.</p><h3>Less Is Often More</h3><p>This is another place where AI architecture can go wrong.</p><p>We often assume:</p><blockquote><strong><em>More context means better decisions</em></strong></blockquote><p>So we add more documents.</p><p>More history.</p><p>More search results.</p><p>More graph relationships.</p><p>More tool outputs.</p><p>But more context is not automatically better context.</p><p>A customer might connect to:</p><pre>Customer<br>   ├── Accounts<br>   ├── Orders<br>   ├── Subscriptions<br>   ├── Support Cases<br>   ├── Devices<br>   ├── Payments<br>   ├── Contracts<br>   └── Preferences</pre><p>A refund agent may need only:</p><pre>Customer → Order → Payment → Refund Policy</pre><p>It probably does not need the customer’s devices.</p><p>It may not need every support case.</p><p>It may not need every contract.</p><p>It may not even need every previous order.</p><blockquote><strong><em>Useful context is often less information, selected well.</em></strong></blockquote><p>The goal is not to give an agent everything the enterprise knows.</p><p>The goal is to give it the <strong>smallest trustworthy view sufficient for the task</strong>.</p><h3>Facts Can Change While the Agent Is Thinking</h3><p>There is another practical problem.</p><p>Suppose the agent checks and sees:</p><pre>Previous refund: None</pre><p>Then it spends several seconds evaluating the request.</p><p>During that time, a human processes the refund.</p><p>Or another agent does.</p><p>Or a fraud system places a hold on the transaction.</p><p>The information was correct when the agent gathered it.</p><p>It is no longer correct when the agent acts.</p><p>So gathering context cannot always be the final step before action.</p><p>For important decisions, the flow may look more like:</p><pre>Gather Context<br>      ↓<br>Reason<br>      ↓<br>Prepare Action<br>      ↓<br>Re-check Important Facts<br>      ↓<br>Re-check Authority<br>      ↓<br>Act</pre><p>And where possible, the business system itself should protect against duplicate or conflicting actions.</p><p>The lesson is simple:</p><blockquote><strong><em>Assembled context is a snapshot. And snapshots age.</em></strong></blockquote><h3>Context Can Be Temporary. Evidence May Need to Last.</h3><p>Now think about what happens after the action.</p><p>Three months later, someone asks:</p><blockquote><strong><em>“Why did the agent approve this refund?”</em></strong></blockquote><p>“The AI decided” is not a useful answer.</p><p>For an important action, we may need to know:</p><ul><li>which customer made the request</li><li>which order was evaluated</li><li>which policy and policy version applied</li><li>what payment status the agent saw</li><li>where that information came from</li><li>what authority the agent had</li><li>what action was requested</li><li>what actually happened</li><li>when it happened</li></ul><p>That does not mean storing every word the model generated.</p><p>And it does not mean keeping everything forever.</p><p>Organizations still have privacy, security, data-retention, and regulatory obligations.</p><p>The principle is simpler:</p><blockquote><strong><em>For important actions, keep enough evidence to explain what happened and why, for as long as the organization legitimately needs it.</em></strong></blockquote><p>The working context may be temporary.</p><p>The evidence needed to explain the action may need to remain longer.</p><h3>Before and After the Decision</h3><p>That gives us two useful views.</p><p>Before and during the decision, we ask:</p><blockquote><strong><em>What does the agent need to know now?</em></strong></blockquote><p>After the decision, we may need to ask:</p><blockquote><strong><em>What did the agent know when it acted, and why did it act?</em></strong></blockquote><p>Together, the flow becomes:</p><pre>Retrieve → Assemble → Decide → Act → Record</pre><p>Over time, those records can become useful organizational memory.</p><p>But notice what we are preserving.</p><p>Not necessarily:</p><blockquote><strong><em>“What was every account balance three months ago?”</em></strong></blockquote><p>Instead:</p><blockquote><strong><em>“What balance did the agent see when it made this decision, where did it get that value, and which policy did it apply?”</em></strong></blockquote><p>Those are very different things.</p><h3>Four Concerns, Not One Giant Graph</h3><p>Put everything together and the architecture starts to look less like one giant graph and more like four related concerns:</p><pre>KNOWLEDGE<br>What do we know?<br>      ↓</pre><pre>CURRENT STATE<br>What is true now?<br>      ↓</pre><pre>CONTEXT<br>What matters for this task?<br>      ↓</pre><pre>EVIDENCE<br>What happened, and why?</pre><p>Or in four principles:</p><blockquote><strong><em>Materialize knowledge.</em></strong><em><br>Preserve durable meaning, relationships, ownership, definitions, policies, and navigation.</em></blockquote><blockquote><strong><em>Resolve state.</em></strong><em><br>Retrieve changing facts from the systems responsible for them when those facts matter.</em></blockquote><blockquote><strong><em>Assemble context.</em></strong><em><br>Bring together only the knowledge, current facts, identity, authority, and constraints needed for the task.</em></blockquote><blockquote><strong><em>Preserve evidence.</em></strong><em><br>For important actions, keep enough information to explain what happened and why.</em></blockquote><p>Or in plain business language:</p><blockquote><strong><em>Remember what is stable.<br>Look up what can change.<br>Bring together only what matters.<br>Keep enough evidence to explain the action.</em></strong></blockquote><h3>Where an Open Knowledge Format Fits</h3><p>There is still a practical question:</p><blockquote><strong><em>How do we package durable enterprise knowledge so both people and AI agents can understand it consistently?</em></strong></blockquote><p>One emerging approach is the <strong>Open Knowledge Format (OKF)</strong>, an open specification introduced in 2026.</p><p>It provides a portable way to package enterprise knowledge such as definitions, metrics, data sources, APIs, policies, runbooks, ownership, and information about where that knowledge came from and how current it is.</p><p>The format itself is not the most important part.</p><p>The important idea is that enterprise knowledge becomes easier for people and agents to:</p><p><strong>discover</strong></p><p><strong>understand</strong></p><p><strong>exchange</strong></p><p><strong>trust</strong></p><p>An agent should not treat:</p><blockquote><strong><em>“I found this definition somewhere.”</em></strong></blockquote><p>the same as:</p><blockquote><strong><em>“This is the current company definition, from a known source, and it has been verified.”</em></strong></blockquote><p>I do not see an open knowledge format as replacing the knowledge graph.</p><p>And it is not the context graph.</p><p>These approaches can complement one another:</p><ul><li><strong>A graph connects knowledge.</strong></li><li><strong>An ontology gives it meaning.</strong></li><li><strong>A catalog helps people and agents find it.</strong></li><li><strong>An open knowledge format helps package and exchange it.</strong></li></ul><p>The larger architectural question stays the same:</p><blockquote><strong><em>What knowledge should persist, what current state should remain with the system responsible for it, and what context should be assembled only when needed?</em></strong></blockquote><h3>Not Everything Fits Into One Bucket</h3><p>Real enterprise architecture will always be messier than a diagram.</p><p>Some current values will be cached.</p><p>Some specific relationships will be stored in the graph.</p><p>Some knowledge will be generated dynamically.</p><p>Some context will last across an entire conversation or workflow.</p><p>That is fine.</p><p>We do not need another rigid architecture rule.</p><p>We need better questions.</p><p>For every piece of information an agent uses, ask:</p><h3>Is this durable knowledge about how the business works?</h3><p>If yes, storing and governing it may make sense.</p><h3>Can this value change, and does its current value affect the decision?</h3><p>If yes, retrieve it from the system responsible for it close enough to the action.</p><h3>Does this matter because of this user, agent, task, authority, or moment?</h3><p>If yes, it probably belongs in the context assembled for that task.</p><h3>Would we need this later to explain an important action?</h3><p>If yes, keep the appropriate evidence for as long as it is legitimately needed.</p><p>Those questions are more useful than simply asking:</p><blockquote><strong><em>Should we copy the data, or leave it where it is?</em></strong></blockquote><h3>The Map Was Never the Destination</h3><p>This brings me back to the progression from my previous article.</p><p><strong>Data products make information manageable.</strong></p><p><strong>Vocabulary makes it consistently named.</strong></p><p><strong>Taxonomy makes it discoverable.</strong></p><p><strong>Ontology makes it understandable.</strong></p><p><strong>Knowledge graphs make it connected.</strong></p><p><strong>Context makes it relevant to the task.</strong></p><p>But relevance does not mean copying everything into another graph.</p><p>A good map does not contain every car moving through the city.</p><p>It gives us enough structure to navigate.</p><p>Current systems tell us what is happening now.</p><p>The route tells us what matters for this particular journey.</p><p>And afterward, the record helps us understand what happened.</p><p>That is how I increasingly think about enterprise AI:</p><blockquote><strong><em>Materialize knowledge.<br>Resolve state.<br>Assemble context.<br>Preserve evidence.</em></strong></blockquote><p>Or even more simply:</p><blockquote><strong><em>Remember what is stable.<br>Look up what can change.<br>Give the agent only what matters.<br>And make sure we can explain what it did.</em></strong></blockquote><p>For years, enterprise architects asked:</p><blockquote><strong><em>Should we move the data, or leave it where it is?</em></strong></blockquote><p>AI agents give us a more useful question:</p><blockquote><strong><em>What should the enterprise remember, what should the agent retrieve from the source, and what should exist only long enough to make the next decision?</em></strong></blockquote><p>And once that decision becomes an action, we should still be able to answer one more question:</p><blockquote><strong><em>Why?</em></strong></blockquote><h3>Related reading</h3><ul><li><a href="https://medium.com/@venkataphanipatelkhana/from-data-products-to-context-graphs-building-the-map-ai-agents-need-cd4aaab8824d">From Data Products to Context Graphs: Building the Map AI Agents Need</a></li><li><a href="https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c">The Enterprise Is Turning Into a Graph, Whether You Planned It That Way or Not</a></li><li><a href="https://venkataphanipatelkhana.medium.com/before-you-give-ai-agents-a-map-you-have-to-build-the-city-86fd83575d2c">Before You Give AI Agents a Map, You Have to Build the City</a></li><li>Next in the series: <strong>Every AI Agent Needs a Map, but Every Map Needs Rules</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df03c2835aa8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Data Products to Context Graphs: Building the Map AI Agents Need]]></title>
            <link>https://venkataphanipatelkhana.medium.com/from-data-products-to-context-graphs-building-the-map-ai-agents-need-cd4aaab8824d?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd4aaab8824d</guid>
            <category><![CDATA[knowledge-graph]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[data-product-manager]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sun, 30 Aug 2026 02:27:26 GMT</pubDate>
            <atom:updated>2026-09-05T17:20:42.713Z</atom:updated>
            <content:encoded><![CDATA[<h3>A real-time city story about how governed data becomes usable enterprise context</h3><p><em>Disclaimer: The opinions expressed in this article are solely my own and do not represent the views or positions of my employer.</em></p><h3>TL;DR</h3><p>An enterprise graph does not create trustworthy facts on its own. It connects facts supplied by identity platforms, customer systems, operational tools, APIs, data platforms, and other domain owners.</p><p>Data products make those inputs easier to discover, understand, govern, and consume. Taxonomy organizes the language. Ontology defines meaning and valid relationships. A knowledge graph connects the enterprise. A context graph assembles the relevant, sufficiently current slice for the task happening now.</p><p>The result is not simply more data for an AI agent. It is a usable enterprise map built from owned and explainable sources.</p><p>In an earlier article, I argued that <a href="https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c">the enterprise is turning into a graph whether organizations planned it that way or not</a>.</p><p>Applications call APIs. Identities receive permissions. Teams own systems. Data moves across domains. Agents select tools and set workflows in motion. The enterprise is increasingly defined not only by what exists, but by how everything connects.</p><p>In the article that followed, I asked a different question: <a href="https://venkataphanipatelkhana.medium.com/before-you-give-ai-agents-a-map-you-have-to-build-the-city-86fd83575d2c">before we give AI agents a map, have we built the city behind it?</a></p><p>That article explored the layers that make an enterprise understandable: taxonomy, ontology, knowledge graphs, RAG, and context graphs.</p><p>But one practical question remained.</p><p>Where do the facts on the map come from?</p><p>A graph can connect a road to a bridge, a hospital to an emergency department, or a customer to an account. It does not automatically tell us who owns those facts, how recently they were updated, what quality level they meet, or whether they may be used for the task in front of us.</p><p>For an AI agent, that difference matters.</p><h3>At 8:17, the city changes</h3><p>At 8:17 on a Monday morning, an accident blocks a major bridge downtown.</p><p>An ambulance is dispatched. A city operations agent is asked to recommend the safest route and identify a nearby hospital that can accept the patient.</p><p>The city has plenty of data:</p><ul><li>The transportation department publishes road closures.</li><li>A traffic platform reports congestion and travel time.</li><li>The emergency service tracks available ambulances.</li><li>Hospitals publish emergency-department capacity.</li><li>The weather service reports flooding and visibility.</li><li>The construction department maintains temporary restrictions.</li></ul><p>On paper, the agent has everything it needs.</p><p>In reality, several questions appear immediately.</p><p>Which road-closure feed is authoritative? How frequently is it updated? Does “closed” mean closed to every vehicle or only to ordinary traffic? Are the hospital-capacity numbers five seconds old or thirty minutes old? Does “available bed” mean an emergency bed, an inpatient bed, or any bed in the building? Is the agent permitted to retrieve the information needed for this specific incident?</p><p>The city has data. The agent still does not have dependable context.</p><p>That is where data products enter the story.</p><h3>A feed is not automatically a data product</h3><p>It is easy to call any dataset or API a data product. But publishing an endpoint does not make the information dependable.</p><p>Think of the bridge-closure service. A useful product around that data should tell consumers more than where the endpoint lives. It should make important operational expectations visible:</p><ul><li>Who owns the product?</li><li>What does it contain?</li><li>How can it be accessed?</li><li>What schema and interface does it expose?</li><li>How frequently is it updated?</li><li>What quality commitments apply?</li><li>What service level should consumers expect?</li><li>What license, contract, or usage restrictions apply?</li><li>Who should be contacted when it fails?</li></ul><p>That is the difference between finding some data and consuming a managed product.</p><p>The <a href="https://opendataproducts.org/">Open Data Products Standards Family</a> makes this distinction concrete. Its foundational Open Data Product Specification, or ODPS, describes the product around the data, including metadata, access, quality, service levels, licensing, pricing, contracts, and strategy.</p><p>Not every enterprise will use every field. The important idea is that the producer makes the product’s promises and conditions explicit enough for people, platforms, and machines to evaluate.</p><p>For our city agent, that changes the question from:</p><blockquote><em>Where can I find road information?</em></blockquote><p>to:</p><blockquote><em>Which managed road-information product is authoritative and fit for this emergency task?</em></blockquote><p>Data products do not guarantee that every fact is correct. They create ownership, structure, and measurable expectations around how the facts are produced and consumed.</p><h3>Taxonomy gives the city an index</h3><p>The agent can now discover managed products. It still needs a consistent way to organize them.</p><p>One department may publish “road incidents.” Another may call them “transport disruptions.” A third may use “mobility events.” If every producer invents its own categories, discovery becomes guesswork.</p><p>A taxonomy provides an agreed category structure. In the city, it might organize products and concepts under headings such as:</p><ul><li>Transportation</li><li>Roads</li><li>Bridges</li><li>Public transit</li><li>Traffic incidents</li><li>Emergency services</li><li>Ambulance operations</li><li>Fire response</li><li>Hospital capacity</li><li>Environment</li><li>Weather</li><li>Flooding</li><li>Air quality</li></ul><p>The taxonomy helps the agent and human operators find related things even when those things come from different systems.</p><p>But a category structure does not explain everything.</p><p>It can tell the agent that an ambulance belongs under emergency services. It does not explain that an ambulance may use a restricted lane during an active response, that a road closure affects a route, or that a hospital’s emergency department serves a particular region.</p><p>For that, the city needs meaning and relationship rules.</p><h3>Ontology explains how the city works</h3><p>An ontology defines the concepts in a domain, the relationships that may connect them, and the constraints that give those relationships meaning.</p><p>In our city model:</p><ul><li>An ambulance is a type of emergency vehicle.</li><li>An emergency vehicle may be assigned to an incident.</li><li>A road segment can be part of a route.</li><li>A closure can affect a road segment.</li><li>A hospital can operate an emergency department.</li><li>An emergency department can report current capacity.</li><li>A route can terminate at a hospital entrance.</li></ul><p>These statements may sound obvious to a person. They are not automatically obvious to software.</p><p>Consider the word “capacity.” A traffic system may use it to describe the number of vehicles a road can handle. A hospital may use it to describe available beds. An infrastructure team may use it to describe compute resources.</p><p>The word is the same. The business meaning is not.</p><p>The ontology stops the agent from treating similar labels as interchangeable facts. It gives the enterprise a shared model of what each concept means and which relationships are valid.</p><p>This is also where precision matters. The Open Data Product Vocabulary, or ODPV, provides shared terms and relationship language across the Open Data Products standards family. That is valuable, but a controlled vocabulary is not automatically a complete domain ontology. An enterprise may use ODPV for consistent product terminology while maintaining additional ontologies for transportation, healthcare operations, identity, customer, finance, or other domains.</p><p>Vocabulary keeps the language consistent. Ontology makes the domain computable.</p><h3>The knowledge graph connects the enduring city</h3><p>Once the city has managed information, shared categories, and defined relationships, it can connect the actual entities.</p><p>Now the model can say:</p><ul><li>Ambulance 42 is assigned to Incident 781.</li><li>Incident 781 occurred near Bridge 6.</li><li>Bridge 6 includes Road Segments 101 through 108.</li><li>Closure 293 affects Road Segments 104 and 105.</li><li>Hospital North operates Emergency Department North.</li><li>Emergency Department North receives its capacity status from the Hospital Capacity data product.</li><li>The transportation department owns the Bridge Closure data product.</li></ul><p>That connected representation is the knowledge graph.</p><p>The taxonomy and ontology describe the structure and meaning. The knowledge graph connects the real city objects, systems, products, owners, and relationships.</p><p>This graph is more useful than a catalog alone. A catalog can tell the agent that a bridge-closure product exists. The graph can show which bridge it describes, which road segments are affected, who owns the product, which routes depend on those segments, and which operational objectives rely on it.</p><p>The Open Data Products family reflects a similar separation of concerns:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5gPFFaM6lHchPmngY35Vpg.png" /></figure><p>These standards can make data-product knowledge easier for humans and machines to inspect and connect. They do not eliminate the need for domain ontologies, enterprise identity, policy systems, or runtime context. They provide structured building blocks those systems can use.</p><h3>The knowledge graph is not the incident view</h3><p>The enterprise knowledge graph may contain every road, bridge, hospital, department, data product, policy, and system in the city.</p><p>The emergency-response agent does not need all of it.</p><p>For Incident 781, it needs a much smaller view:</p><ul><li>The current incident</li><li>Ambulance 42 and its location</li><li>Candidate hospitals within a reasonable distance</li><li>Current emergency-department capacity</li><li>Active road closures</li><li>Current traffic and weather conditions</li><li>The products and sources behind those facts</li><li>The applicable emergency-routing rules</li><li>The freshness requirements for this decision</li></ul><p>In this architecture, that task-specific view is the <strong>context graph</strong>.</p><p>The context graph is not simply a smaller copy of the enterprise graph. It can combine stable relationships with current state and decision-specific evidence.</p><p>The knowledge graph may know that Bridge 6 connects two districts. The context graph adds that Road Segment 104 is closed now, Ambulance 42 is approaching from the south, Hospital North reported capacity thirty seconds ago, and this incident has been classified as high priority.</p><p>The knowledge graph provides orientation.</p><p>The context graph provides the situation.</p><h3>“Real time” means current enough for the decision</h3><p>There is a temptation to call every context system real time. That phrase needs care.</p><p>Not every data product is a stream, and not every decision requires millisecond updates. A hospital’s location may change rarely. Emergency-department capacity may need frequent updates. A road closure can change between planning a route and reaching the bridge.</p><p>The correct freshness requirement depends on the fact and the decision.</p><p>For the city agent, a thirty-minute-old hospital address may be perfectly acceptable. A thirty-minute-old capacity report may not be.</p><p>This is why freshness should be evaluated as part of fitness for use, not treated as one global timestamp. The context layer should preserve when a fact was observed, which product supplied it, what freshness commitment applies, and whether the evidence remains acceptable for the current task.</p><p>If the bridge status becomes stale, the agent should not quietly assume the road is open. It should obtain fresher evidence, choose a safer alternative, request human review, or fail closed — depending on the operating policy.</p><p>Freshness is not a dashboard decoration. It can change the decision.</p><h3>Correct facts can still create the wrong context</h3><p>Suppose each source reports something true:</p><ul><li>Hospital North has ten available beds.</li><li>The ambulance is twelve minutes away.</li><li>The bridge connects the ambulance’s location to the hospital.</li></ul><p>The agent could still make the wrong recommendation.</p><p>Those ten beds may not be emergency beds. The bridge may be closed to ordinary vehicles but open to emergency responders — or the reverse because of structural damage. The twelve-minute estimate may have been calculated before the accident blocked the road.</p><p>Every fact can be individually correct while their combination is unsuitable for the task.</p><p>That is why the path from data product to context graph needs more than connectivity. It needs:</p><ul><li>Clear source ownership</li><li>Agreed meaning</li><li>Provenance and transformation history</li><li>Fact-specific freshness checks</li><li>Compatible units, identifiers, and time windows</li><li>Rules for combining facts across domains</li><li>Access controls that limit which facts may enter the context</li></ul><p>The graph shows relationships. Governance determines which relationships and facts are safe to rely on.</p><h3>This assumes a maturity most enterprises don’t have yet</h3><p>It’s worth being honest about the gap between this picture and where most organizations actually start. The scenario above assumes every relevant department already publishes governed, well-described, appropriately fresh data products.</p><p>In practice, most enterprises are sitting on decades of feeds with no clear owner, no documented schema, no freshness commitment, and no one left who remembers why a field is named what it’s named. Retrofitting ODPS-style metadata onto that landscape, department by department, is slow, political work — it’s not a technology rollout, it’s an organizational one, and it will lag behind the AI agents that everyone wants to deploy on top of it. None of that invalidates the target architecture.</p><p>It does mean the realistic path is incremental: start with the highest-stakes data products (the ones an agent’s decisions actually hinge on, like hospital capacity or bridge status) rather than trying to graph the whole city on day one.</p><h3>What the agent finally receives</h3><p>By the time the city operations agent evaluates the emergency, it should not receive an unfiltered dump of every available dataset.</p><p>It should receive a compact, explainable context:</p><ul><li><strong>Incident:</strong> Collision near Bridge 6</li><li><strong>Responder:</strong> Ambulance 42</li><li><strong>Destination candidates:</strong> Hospital North and Hospital West</li><li><strong>Route status:</strong> Segments 104 and 105 closed</li><li><strong>Hospital capacity:</strong> North unavailable for emergency intake; West accepting patients</li><li><strong>Weather:</strong> Reduced visibility on the northern route</li><li><strong>Evidence:</strong> Source products, observation times, owners, and quality status attached</li><li><strong>Applicable rules:</strong> Emergency-routing and data-use policies identified</li></ul><p>The agent can now recommend Hospital West and explain why.</p><p>More importantly, an operator can examine the recommendation and see where the supporting facts came from.</p><p>That is the real journey:</p><p><strong>Data products make information manageable.</strong><br><strong>Vocabulary makes it consistently named.</strong><br><strong>Taxonomy makes it discoverable.</strong><br><strong>Ontology makes it understandable.</strong><br><strong>The knowledge graph makes it connected.</strong><br><strong>The context graph makes it relevant to the task.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N_TYanENoBKsS4BAaIbRzA.png" /></figure><h3>The map is ready. The authority question is not.</h3><p>The city operations agent now has a useful map. It can identify the ambulance, incident, roads, closures, hospitals, data products, and evidence needed to recommend a route.</p><p>But visibility is not authority.</p><p>Knowing that a hospital-capacity product exists does not mean every agent may read it. Seeing that an emergency route crosses a restricted road does not mean every vehicle may use it. Discovering an API does not grant permission to call it. Finding a technically possible action does not mean the action is approved.</p><p>The map answers:</p><blockquote><em>What is connected, and what matters now?</em></blockquote><p>It does not answer:</p><blockquote><em>Is this agent, acting for this user and purpose, allowed to take this action under the current conditions?</em></blockquote><p>That is the next boundary in the story.</p><p>The enterprise became a graph. We built the city behind it. Data products, taxonomy, ontology, knowledge graphs, and context graphs turned that city into a usable map.</p><p>Now the map needs rules.</p><h3>Related reading</h3><ul><li><a href="https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c">The Enterprise Is Turning Into a Graph, Whether You Planned It That Way or Not</a></li><li><a href="https://venkataphanipatelkhana.medium.com/before-you-give-ai-agents-a-map-you-have-to-build-the-city-86fd83575d2c">Before You Give AI Agents a Map, You Have to Build the City</a></li><li>Next in the series: <strong>Every AI Agent Needs a Map, but Every Map Needs Rules</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd4aaab8824d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Before You Give AI Agents a Map, You Have to Build the City]]></title>
            <link>https://venkataphanipatelkhana.medium.com/before-you-give-ai-agents-a-map-you-have-to-build-the-city-86fd83575d2c?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/86fd83575d2c</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[knowledge-graph]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 17:32:42 GMT</pubDate>
            <atom:updated>2026-07-25T17:32:42.135Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why taxonomy, ontology, knowledge graphs, RAG, and context graphs all matter</h4><p><strong><em>Disclaimer:</em></strong><em> The opinions expressed are solely my own and do not reflect the views or positions of my employer</em></p><p><strong>TL;DR:</strong> AI agents need more than intelligence. They need an enterprise they can understand. Before building knowledge graphs, RAG pipelines, or context systems, organizations must first establish a shared language, meaningful relationships, and a connected representation of how the business works. Only then can AI agents navigate enterprise decisions with confidence.</p><p>Lately, there has been a lot of talk about giving AI agents better context. Knowledge graphs. Enterprise graphs. Context graphs. Enterprise memory. Context engineering. It can sound as if every new layer is the missing foundation for enterprise AI.</p><p>I do not think that is quite the right way to look at it.</p><p>The better question is:</p><p><strong>Where does the map actually come from?</strong></p><p>That question changed the way I think about enterprise AI.</p><p>If you were building a city for autonomous vehicles to navigate, you would not start by drawing the map. You would first define the language, the structures, the relationships, and the rules that make the city navigable in the first place.</p><p>That is the real challenge for enterprise AI.</p><p>In a previous article, I wrote about why I believe modern enterprises are naturally evolving into graphs as relationships become just as important as the systems themselves. This article builds on that idea by exploring a different question: <strong>if the enterprise is becoming a graph, how does an AI agent actually learn to navigate it?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ey8zZ5mdUg4f0-Wrf5Lsvw.png" /><figcaption>A simple mental model for how enterprise understanding is built — from shared language and relationships to knowledge, live context, and AI decision making</figcaption></figure><h3>You Do Not Start With the Map</h3><p>A map is useful only after the city begins to exist.</p><p>Before navigation comes vocabulary.</p><p>Before geography comes structure.</p><p>Before routes come rules.</p><p>If you were designing a new city, you would first need shared names for things.</p><p>What counts as a hospital?</p><p>A school?</p><p>A highway?</p><p>A residential district?</p><p>Without common language, every planner, contractor, and emergency responder could describe the same place differently.</p><p>Enterprises have the same problem.</p><p>Marketing may define a customer one way.</p><p>Finance may define it another.</p><p>Sales may use <em>account</em> differently from Operations.</p><p>One system may say <em>supplier</em>.</p><p>Another may say <em>vendor</em>.</p><p>A third may say <em>business partner</em>.</p><p>Before AI agents can understand an enterprise, the enterprise has to agree on its language.</p><p>That is where taxonomy matters.</p><p>Taxonomy does not make decisions.</p><p>It creates consistency.</p><p>It gives people and systems a shared vocabulary so they can talk about the same things without constant translation.</p><h3>Meaning Comes Next</h3><p>Names alone are not enough.</p><p>A hospital is not just another building.</p><p>It provides healthcare.</p><p>A school educates students.</p><p>A fire station protects a community.</p><p>Roads connect neighborhoods.</p><p>Bridges connect places that would otherwise stay isolated.</p><p>At that point, the city stops looking like a list of addresses and starts behaving like a system.</p><p>Enterprises work the same way.</p><p>Customers purchase products.</p><p>Employees approve requests.</p><p>Applications call APIs.</p><p>Services publish events.</p><p>Policies govern access.</p><p>Teams own business capabilities.</p><p>Identities receive permissions.</p><p>Individually, those facts are useful.</p><p>Together, they reveal how the business actually works.</p><p>That is where ontology becomes important.</p><p>Ontology defines meaning, relationships, and constraints.</p><p>It explains not just what something is, but how it relates to everything else.</p><p>Without that layer, AI agents may recognize terms but still misunderstand the business.</p><h3>Then You Can Build the Map</h3><p>Only after language and meaning are established does a map become truly useful.</p><p>Now every road, building, bridge, and utility can be connected in a way that reflects the real city.</p><p>You can trace dependencies, ownership, access, and movement.</p><p>You can ask not only where something is, but how it fits into the larger system.</p><p>That is the role of an Enterprise Knowledge Graph.</p><p>An Enterprise Knowledge Graph connects customers, employees, applications, APIs, documents, identities, policies, business capabilities, and data assets into a navigable representation of the organization.</p><p>That allows different questions:</p><ul><li>Which business capability does this application support?</li><li>Which APIs does it depend on?</li><li>Which customer processes rely on it?</li><li>Who owns it?</li><li>Which identities can access it?</li><li>Which policies apply?</li></ul><p>The question shifts from:</p><p><strong>“What exists?”</strong></p><p>to</p><p><strong>“How is everything connected?”</strong></p><p>A traditional inventory tells you what you have.</p><p>An Enterprise Knowledge Graph tells you how it all relates.</p><h3>RAG Is the Library, Not the City</h3><p>Even with a perfect map, there are things the roads cannot tell you.</p><p>A building inspector may need the latest code.</p><p>A firefighter may need an emergency procedure.</p><p>An engineer may need a maintenance manual.</p><p>A driver may need parking rules at a destination.</p><p>Those answers do not come from the map.</p><p>They come from the city’s documents, manuals, policies, and records.</p><p>That is where Retrieval-Augmented Generation (RAG) fits in.</p><p>RAG helps an AI system retrieve relevant documents, policies, runbooks, procedures, and other unstructured knowledge so the model can answer using supporting evidence.</p><p>It is the library.</p><p>The Enterprise Knowledge Graph is different.</p><p>It explains structure and relationships.</p><p>RAG finds supporting information.</p><p>The graph explains where that information belongs in the enterprise.</p><p>They solve different problems, and they work best together.</p><p>For example, an agent may use RAG to retrieve a policy document.</p><p>It may then use the Enterprise Knowledge Graph to determine which applications, users, data classifications, and business processes that policy applies to.</p><p><strong>Together, they provide something neither can provide alone.</strong></p><h3>A Map Is Not a Live System</h3><p>Now imagine opening <strong>Google Maps</strong> without a live connection.</p><p>You can still see roads.</p><p>Cities.</p><p>Highways.</p><p>Landmarks.</p><p>Possible routes.</p><p>Reconnect to live services and suddenly you can also see:</p><p>Traffic congestion.</p><p>Accidents.</p><p>Construction.</p><p>Road closures.</p><p>Weather conditions.</p><p>Travel delays.</p><p>Alternate routes.</p><p><strong>The map is the same.</strong></p><p><strong>The conditions are not.</strong></p><p>That is the difference between an Enterprise Knowledge Graph and a Context Graph.</p><p>The Enterprise Knowledge Graph captures the enterprise structure.</p><p>The Context Graph captures the current operating state across that structure.</p><p>Who is the current user?</p><p>Which agent is acting on their behalf?</p><p>What authority does it have?</p><p>Which tenant owns the data?</p><p>Has a human approved the action?</p><p>Has a policy changed?</p><p>Is a downstream service unavailable?</p><p>Has the risk level increased?</p><p>That live state matters because enterprise decisions are rarely based on structure alone.</p><h3>Existence Is Not Permission</h3><p>This distinction matters because a route existing does not mean it should be taken.</p><p>A road may connect two parts of a city, but it may be closed, restricted, unsafe, or unavailable at certain times.</p><p>The same is true in enterprise systems.</p><p>A graph may show that an AI agent can reach an API.</p><p>Runtime context may show that:</p><ul><li>The user is not authorized for the requested data.</li><li>The action crosses a tenant boundary.</li><li>The approval has expired.</li><li>The system is in read-only mode.</li><li>The operation carries unusual risk.</li><li>The agent’s current task does not require that API.</li></ul><p>The connection exists.</p><p>The decision can still change.</p><p>That is why context is not just more data added to a graph.</p><p>It is the information needed to decide what should happen <strong>now</strong>.</p><h3>What the Agent Needs</h3><p>Enterprise AI agents do not just need intelligence.</p><p>They need orientation.</p><p>They need the enterprise’s language.</p><p>They need its meanings.</p><p>They need its structure.</p><p>They need its documents.</p><p>They need its current state.</p><p>They need to know its boundaries.</p><p>That is what turns a capable model into a trustworthy enterprise agent.</p><p>A simple way to remember it is:</p><ul><li><strong>Taxonomy</strong> organizes the language.</li><li><strong>Ontology</strong> defines meaning and relationships.</li><li><strong>The Enterprise Knowledge Graph</strong> creates the map.</li><li><strong>RAG</strong> retrieves supporting knowledge from the library.</li><li><strong>The Context Graph</strong> adds live conditions.</li><li><strong>The AI agent</strong> decides what to do next.</li></ul><p>Or even more simply:</p><blockquote><strong><em>RAG finds information.</em></strong></blockquote><blockquote><strong><em>The graph explains relationships.</em></strong></blockquote><blockquote><strong><em>Context explains the current situation.</em></strong></blockquote><blockquote><strong><em>The agent makes the decision.</em></strong></blockquote><h3>The Better Question</h3><p>Organizations often ask which graph technology they should build.</p><p>That is not the best question.</p><p>A better question is:</p><p><strong>Have we built an enterprise that AI agents can actually understand?</strong></p><p>Maps do not create cities.</p><p>They help people navigate them.</p><p>Enterprise Knowledge Graphs do not replace documents.</p><p>RAG does not replace graphs.</p><p>Context does not replace either one.</p><p>Each serves a different purpose.</p><p>We spend a lot of time talking about making AI models smarter.</p><p>But smarter models will not fix an enterprise that is difficult to understand.</p><p>Before AI agents can navigate the enterprise, the enterprise itself has to become navigable.</p><p>Because the real challenge is not simply building <strong>smarter</strong> agents.</p><p>It is building an enterprise they can understand — and a live map they can trust.</p><p><strong>If you’re interested in why I believe enterprise relationships are becoming the new architectural foundation, you may also enjoy my earlier article:</strong></p><p><strong>Related Reading:</strong><br>👉 <strong><em>The Enterprise Is Turning Into a Graph, Whether You Planned It That Way or Not</em></strong> <a href="https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c">https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=86fd83575d2c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Enterprise Is Turning Into a Graph, Whether You Planned It That Way or Not]]></title>
            <link>https://venkataphanipatelkhana.medium.com/the-enterprise-is-turning-into-a-graph-whether-you-planned-it-that-way-or-not-72387b578f7c?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/72387b578f7c</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sat, 11 Jul 2026 19:51:06 GMT</pubDate>
            <atom:updated>2026-07-12T00:43:12.180Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>As AI agents, APIs, identities, and data become more connected, enterprise governance is shifting from inventories to relationships.</strong></h4><p><strong><em>Disclaimer:</em></strong><em> The opinions expressed are solely my own and do not reflect the views or positions of my employer</em></p><p><strong>TL;DR:</strong> The modern enterprise is quietly becoming a graph of relationships, not just a catalog of systems. AI agents, APIs, identities, tools, and datasets now interact through many-to-many paths, and much of the risk lives in those connections. Treating this as an enterprise graph helps organizations reason about who can call what, on whose behalf, against which data, and under which policy. Without explicitly modeling and governing that graph, it will still emerge on its own, but with shadow access paths, fragile dependencies, and ungoverned agent behavior.</p><p>Every few years, enterprise architecture finds a new center of gravity. It used to be applications. Then APIs. Then microservices. Then events. Lately, without much fanfare, it has become graphs.</p><p>Customer graphs. Identity graphs. Knowledge graphs. Lineage graphs. API dependency graphs. Security exposure graphs. Now, agent-tool graphs. Different teams have different names for it, but they are all chasing the same thing: a picture of how everything connects.</p><p>That is the real shift. Not more data. More relationships.</p><h3>The city problem</h3><p>Here is a way to think about it. A record-based system is a building registry. It tells you what exists: every address, owner, and permit. Useful. Every city needs one.</p><p>But a registry does not tell you how the city actually runs. It will not tell you which roads connect which neighborhoods, where the shortcuts are, which zones are off-limits, or what happens when a delivery truck needs to cross three of them to get somewhere. A graph gives you that instead: not just what exists, but what is reachable, and under what rules.</p><p>Most enterprises have spent decades building excellent registries. What they are missing is the map.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*db52ESYxQFZrTxpRu0aJnA.png" /></figure><h3>The questions got harder</h3><p>Old-school enterprise systems were good at answering “what is this thing?” Customer record. Order record. User record. Fine. That worked when the questions stayed simple.</p><p>They do not anymore. Who has access to this data, and through what path did they get it? Which agents can reach this API, directly or by way of some tool three steps removed? If this service goes down, what else goes down with it? What data, tools, and approvals actually touched this AI-generated answer before it reached someone’s screen?</p><p>None of those are simple lookups. They are path questions.</p><p>And you usually cannot answer a path question well with isolated tables. You need a model of how things connect.</p><h3>Why AI is forcing the issue</h3><p>A model can hand you an answer in half a second. What it cannot do on its own is tell you where that answer came from, what it touched to get there, or whether it should have been allowed to touch it.</p><p>Agents make this sharper. An agent is not a static endpoint. It plans, picks tools, calls APIs, and sets workflows in motion. Think of it as an autonomous delivery vehicle. It does not sit parked at one address. It picks routes, crosses zones, carries cargo, and sometimes triggers things downstream that nobody is watching in real time.</p><p>Governing that is not about knowing the vehicle exists. It is knowing which routes it is allowed to take, what it is allowed to carry, which zones need a permit first, and what breaks when someone opens a new bridge. So the governance question stops being “does this system exist?” and becomes: what becomes reachable through this path, and should it be allowed?</p><h3>It is bigger than graph databases</h3><p>When people hear “graph,” they usually picture a graph database. That is one implementation, not the idea.</p><p>The real point is that a lot of your existing systems are already graphs. They just do not advertise it. A developer portal is not a list of APIs. It is a web of APIs, owners, consumers, environments, gateways, and versions, all tied together. An identity platform is not a user list. It is users, groups, roles, service accounts, tenants, and entitlements, wired together by who is allowed to touch what. A data platform is not a pile of datasets. It is datasets, owners, classifications, lineage, and the regulatory lines running through all of it.</p><p>An AI platform is the newest version of this: users, prompts, data sources, agents, tools, MCP servers, approvals, and the audit trail connecting them.</p><p>It does not matter if the underlying tech is a graph database, a semantic layer, a CMDB, or a combination of existing platforms stitched together. What matters is that relationships and lineage are becoming things systems need to query, not things buried in a diagram someone drew two years ago and never updated.</p><h3>What I mean by an enterprise graph</h3><p>When I talk about an <strong>enterprise graph</strong>, I am not referring only to a graph database or a knowledge graph.</p><p>I am describing a <strong>software layer that represents the enterprise’s relationships, dependencies, context, and governance in a form that both applications and AI agents can query and reason over.</strong></p><p>The graph does not replace identity systems, APIs, policy engines, or enterprise applications. It provides the contextual map that helps answer questions such as <strong>what is connected, what becomes reachable, which policy applies, and whether an action should be allowed.</strong></p><h3>The problem with building graphs in silos</h3><p>Most companies are already building these graphs. The trouble is they are building them apart from each other. Security owns the exposure graph. Identity owns the access graph. Platform teams own API dependencies. Data teams own lineage. And now AI teams are standing up their own agent-tool graphs, often without much conversation with anyone else on that list.</p><p>Each one is useful on its own. None of them, alone, can answer a real cross-domain question.</p><p>Here is a scenario that is about to become extremely common. An agent calls a tool. The tool hits an internal API. The API returns customer data. That data belongs to a regulated tenant. The person who kicked off the whole chain is not actually cleared for that tenant. If identity lives in IAM, classification lives in a catalog, the API lives in a developer portal, and the agent configuration lives somewhere else entirely, nobody has a reliable answer to the only question that matters in the moment: should this be allowed to happen right now?</p><p>Every one of those systems can be perfectly correct on its own, and the organization can still get this wrong, because the answer only exists in the relationship between them.</p><p>That is the real argument for an enterprise graph. Not a nicer dashboard, but a piece of the decision-making layer itself, sitting alongside IAM, API gateways, and policy engines. It does not replace them. It connects what they each already know.</p><p>The graph is not the enforcement point by itself. It gives enforcement systems the context they need to make better decisions.</p><h3>The outcome: governed reachability</h3><p>The real payoff of an enterprise graph is not a prettier map. It is governed reachability.</p><p>Can this user reach this data through this agent? Can this tool expose a regulated dataset through an API? Can this workflow cross a tenant boundary? What becomes reachable if someone bolts a new tool onto an existing agent’s path?</p><p>A good graph does not just show relationships. It helps the organization reason about what those relationships make possible. An address book does not keep a city safe. Understanding routes, restrictions, and choke points does.</p><h3>One catch: the graph has to earn trust</h3><p>Here is the part that is easy to skip past. A graph is only as good as its freshness, and graphs go stale in ways that are easy to miss.</p><p>Ownership gets out of date. A dependency gets removed and nobody updates the map. An agent picks up a new tool and the graph does not know about it yet. A dataset gets reclassified and the old label lingers.</p><p>If the graph is just documentation, stale data is annoying. If it is what your AI grounds itself in, or what a security review relies on, or what makes a runtime authorization call, stale data is dangerous. It gives you false confidence.</p><p>Which means the graph itself needs the same discipline as any critical system: clear ownership, freshness checks, audit trails, access control, lifecycle management. Not a side project someone stood up in a hackathon.</p><h3>A concrete walk-through</h3><p>Say you have an agent helping support reps resolve tickets. A user asks a question. The agent picks a troubleshooting skill. That skill calls a tool. The tool hits a customer API. The API returns account data. The agent recommends a refund or prepares it for approval.</p><p>The old-style check is “is this user logged in?” The graph-aware version asks a longer chain of questions: is this user allowed to use this agent at all? Is this agent approved for support workflows? Is this tool approved for this agent? What is actually behind the API it is calling? Does the user have rights to that specific customer’s data? Does this action need a human sign-off? Has this exact path been used, and trusted, before?</p><p>That is the real gap between checking a fact and reasoning across a path.</p><h3>Where this leaves things</h3><p>Every company is already building pieces of this. Some of it is sitting in identity systems, some in data catalogs, some in security tooling, and increasingly some inside the platforms running their AI agents.</p><p>The opportunity is not another graph nobody talks to. It is connecting the graphs that already exist and treating those connections as something to be governed, not assumed.</p><p>The question is shifting from:</p><p><strong>What systems do we have?</strong></p><p>to:</p><p><strong>How are they connected, who can reach what through them, and what should be allowed to happen next?</strong></p><p>Organizations that take that second question seriously will have a real head start as AI agents begin making decisions across more systems.</p><p>The enterprise will need more than an inventory of systems. It will need a living understanding of relationships, reachability, and policy.</p><p><strong>That, to me, is what an enterprise graph really is.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72387b578f7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smart, Confident, and Completely Unsupervised — Why AI Agents Fail in Production]]></title>
            <link>https://venkataphanipatelkhana.medium.com/smart-confident-and-completely-unsupervised-why-ai-agents-fail-in-production-b420a5a284b2?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/b420a5a284b2</guid>
            <category><![CDATA[ai-agents-in-action]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 22:19:41 GMT</pubDate>
            <atom:updated>2026-04-21T00:53:36.615Z</atom:updated>
            <content:encoded><![CDATA[<h3>Smart, Confident, and Unsupervised — Why AI Agents Fail in Production</h3><h4>A production AI agent is not a model. It’s a system — built on layers that control what enters, what executes, and what persists.</h4><p><strong><em>Disclaimer:</em></strong><em> The opinions expressed are solely my own and do not reflect the views or positions of my employer</em></p><p>TL;DR</p><p>AI agents don’t fail because the model is bad.</p><p>They fail because there’s no system around them.</p><p>In demos, everything looks great.</p><p>In production, things fall apart — no guardrails, no control, no visibility.</p><p>That’s the real issue:</p><p>we build smart agents, but not controlled systems.</p><p>👉 Intelligence without structure is unpredictable</p><p>👉 Production agents need architecture — not just models</p><p>Let me paint you a picture.</p><p>A team deploys a support agent.</p><ul><li>Strong LLM</li><li>Clean prompts</li><li>Solid tool integrations</li></ul><p>In staging, everything works beautifully:</p><ul><li>It classifies urgency</li><li>Drafts responses</li><li>Escalates edge cases correctly</li></ul><p>They ship it.</p><p>Two weeks later:</p><ul><li><strong>78% of tickets are escalated</strong></li><li>Support teams are drowning</li><li>Response times are worse than before automation</li></ul><p>Nothing broke.<br> The model didn’t degrade.<br> The prompts didn’t change.</p><p><strong>The agent worked exactly as designed.</strong></p><p>That was the problem.</p><p>Teams pour everything into the model — prompts, fine-tuning, tool calls — and then drop that intelligence into production with <strong>no system around it</strong>.</p><p>A production AI agent is not a model.</p><blockquote><strong><em>A production agent runs on 3 runtime layers, governed by a control plane and instrumented by observability.</em></strong></blockquote><p>Miss any one of these — and the system doesn’t degrade gracefully.<br> It fails unpredictably.</p><p>Every failure story below is a missing layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C75k8aQZk0qmJNuXy4U6Lw.png" /></figure><h3>The agent that cried wolf</h3><p>Back to that 78% escalation rate.</p><p>The agent found a shortcut.</p><p>Words like:</p><ul><li>“broken”</li><li>“not working”</li><li>“can’t access”</li></ul><p>→ triggered escalation almost every time.</p><p>Not because the model misunderstood — <br> but because nobody defined what <em>“urgent”</em> actually means.</p><p>Think of a railway signal system:</p><ul><li>Green → proceed</li><li>Yellow → caution</li><li>Red → stop</li></ul><p>No interpretation. No ambiguity.</p><p>This agent had no signals.</p><p>So it defaulted to the safest behavior:<br> → treat everything as critical.</p><p>From the agent’s perspective, that’s rational.<br> From the support team’s perspective, it’s an avalanche.</p><p><strong>Root cause:</strong> Missing structure in the execution layer (skills).</p><p><strong>Fix:</strong></p><ul><li>Define severity tiers</li><li>Remove ambiguity</li><li>Monitor escalation drift</li></ul><h3>The agent that invented company policy</h3><p>A billing assistant starts issuing credits.</p><p>Customer: <em>“Can I get a refund?”</em><br> Agent: <em>“Absolutely. Based on our 30-day guarantee…”</em></p><p>There is no such policy.</p><p>The agent didn’t break anything.<br> It filled a gap.</p><p>It could:</p><ul><li>explain refunds</li><li>access billing tools</li></ul><p>But nobody defined:</p><ul><li>what it can <strong>explain</strong></li><li>vs what it can <strong>execute</strong></li></ul><p>So it invented authority.</p><p>At scale.</p><p><strong>Root cause:</strong> Missing control plane governance.</p><p><strong>Fix:</strong></p><ul><li>Register policies explicitly</li><li>Define execution boundaries</li><li>Enforce them at the gateway</li></ul><blockquote><em>Agents describe outcomes. Systems execute decisions.</em></blockquote><h3>The agent with no front door</h3><p>An agent goes live without a proper gateway.</p><p>Three things happen:</p><ol><li>Prompt patterns start influencing behavior</li><li>During outages, the agent responds confidently with bad data</li><li>Unauthorized or out-of-policy requests reach the model</li></ol><p>A railway without stations doesn’t move faster.<br> It loses control.</p><p>A station is where:</p><ul><li>access is validated</li><li>routes are assigned</li><li>unsafe entry is blocked</li></ul><p>That’s your <strong>perimeter layer</strong>.</p><p><strong>It must:</strong></p><ul><li>authenticate and authorize</li><li>enforce policy before reasoning</li><li>apply guardrails (prompt injection, PII, content filtering)</li><li>run health checks</li></ul><p>Not as an add-on.<br> <strong>As the front door.</strong></p><h3>The agent that forgot its customers</h3><p>One customer. One week.</p><ul><li>Monday: Answer A</li><li>Wednesday: Answer B (contradiction)</li><li>Friday: Answer C (different again)</li></ul><p>Each answer is reasonable.<br> Together, they destroy trust.</p><p><strong>Root cause:</strong> No state layer.</p><p>Every interaction resets to zero.</p><p>Like a railway with no ticketing system:</p><ul><li>no journey history</li><li>no continuity</li></ul><p><strong>Fix:</strong></p><ul><li>persistent conversation memory</li><li>stored decisions</li><li>cross-session context</li></ul><p>Not perfect memory — just consistent enough.</p><h3>The agent that succeeded too well</h3><p>This one looks like success.</p><ul><li>Resolution rate: 98%</li><li>Dashboards: green</li></ul><p>But:</p><ul><li>credits issued incorrectly</li><li>promises can’t be fulfilled</li><li>complaints marked resolved prematurely</li></ul><p>Two weeks later → trust collapses.</p><p>The agent optimized the metric it was given.</p><p><strong>Root cause:</strong> Gameable metrics + weak evaluation.</p><p><strong>Fix:</strong></p><ul><li>Evaluate correctness, not just completion</li><li>Track downstream impact</li><li>Detect repeated issues</li></ul><h3>The agent that failed in silence</h3><p>Accuracy drops:</p><ul><li>94% → 61%</li></ul><p>No alerts.<br> No errors.<br> No visibility.</p><p>Weeks of bad decisions propagate.</p><p>This is <strong>distribution shift</strong>.</p><p>A railway with no control room:</p><ul><li>trains move</li><li>routes drift</li><li>nobody notices</li></ul><p><strong>Root cause:</strong> Missing observability.</p><p><strong>Fix:</strong></p><ul><li>accuracy tracking</li><li>confidence monitoring</li><li>drift detection</li><li>automated alerts</li></ul><p>These signals should flow into systems like:</p><ul><li>Splunk</li><li>Datadog</li><li>Grafana</li></ul><p>Using standards like OpenTelemetry.</p><p>Silent failure is the most expensive kind.</p><h3>What a production-ready agent actually looks like</h3><p>Every failure above has the same root cause:<br> <strong>there is no system around the intelligence.</strong></p><p>You’re not deploying a model.<br> You’re deploying a controlled system.</p><blockquote>Think about a railway system. Signals define behavior. Stations control access. The control room monitors flow. And without the railway itself, nothing works at all.</blockquote><p>That system only works when intelligence is wrapped in structure.</p><blockquote><strong><em>A production agent runs on 3 runtime layers, governed by a control plane and instrumented by observability.</em></strong></blockquote><h3>1. Perimeter (Gateway) — controls what enters</h3><ul><li>Authentication &amp; authorization</li><li>Policy enforcement</li><li>Rate limits</li><li>Guardrails</li><li>Health checks</li></ul><p>If this layer fails, everything downstream becomes irrelevant.</p><h3>2. Execution Layer — controls what happens</h3><ul><li>Orchestration manages flow</li><li>LLM provides reasoning (not authority)</li><li>Skills define boundaries</li><li>MCP governs tool/data access</li></ul><p>The model never directly executes actions.</p><h3>3. State Layer — controls what persists</h3><ul><li>Conversation memory</li><li>Stored decisions</li><li>Continuity across sessions</li></ul><p>This prevents contradiction and loss of context.</p><h3>4. Observability — sees everything</h3><p>Cross-cutting across all layers:</p><ul><li>traces</li><li>metrics</li><li>drift detection</li><li>alerts</li></ul><p>Answers:</p><ul><li>What happened?</li><li>Why?</li><li>Is it still correct?</li></ul><h3>5. Control Plane — defines everything</h3><ul><li>policies</li><li>subscriptions</li><li>skills</li><li>tool access</li></ul><p><strong>Separation is critical:</strong></p><ul><li>Control plane defines</li><li>Gateway enforces</li><li>Execution trusts</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ioEbgt1n67sPA-RSPlcUfQ.png" /><figcaption>A production grade agent archietecture</figcaption></figure><h3>Before you ship: a pre-production checklist</h3><p>Before any agent goes live, pressure-test these:</p><p><strong>Control plane:</strong> Are subscriptions, policies, skills, and MCP connections registered in the marketplace? Does every capability have a clear owner and boundary?</p><p><strong>Perimeter (gateway):</strong> Can an unauthenticated or adversarial request reach the model? Are guardrails active — input validation, prompt injection detection, content filtering, PII screening? What happens when a backend dependency is down?</p><p><strong>Execution:</strong> For every tool the agent can access, is there a clear boundary between what it can explain and what it can execute? Are there decisions the agent should never make autonomously?</p><p><strong>State (memory):</strong> If a customer talks to the agent three times this week, will it contradict itself? How would you know?</p><p><strong>Observability:</strong> Are traces, metrics, and drift detection instrumented across every layer — gateway, orchestration, and memory? Are logs shipping to your SIEM and APM platforms so your ops team can see agent telemetry alongside everything else?</p><p><strong>Evaluation:</strong> What does “correct” mean for this agent’s outputs? How will you measure it? How will you detect when it degrades?</p><p><strong>Metrics:</strong> Is the agent’s success metric gameable? What would over-optimization look like, and would your monitoring catch it?</p><p>If you can’t answer these confidently, you’re not ready to ship. You have an engine. You don’t yet have a system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-8LXjKi08YNyZDxryQ0grQ.png" /></figure><h3>The real takeaway</h3><p>Most teams are still focused on the engine — tuning prompts, swapping models, testing in staging and assuming production will behave the same way.</p><p>It won’t. Production has real users, unpredictable inputs, and slow drift that looks like stability until it doesn’t.</p><p>The model is rarely the problem. The missing infrastructure is — the invisible layers that control what the agent can do, govern what it can see, enforce how it behaves, and detect when it starts to drift.</p><p>An AI agent without guardrails, skills, memory, and control isn’t automation. It’s confident software making unsupervised decisions in production.</p><p>That’s not intelligence. That’s unmanaged risk.</p><p><strong>Ship the system, not just the engine.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b420a5a284b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who’s Running City Hall? AI Agents Need a Control Plane]]></title>
            <link>https://venkataphanipatelkhana.medium.com/whos-running-city-hall-ai-agents-need-a-control-plane-8b3b34031464?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b3b34031464</guid>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[enterprise-technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 05:08:36 GMT</pubDate>
            <atom:updated>2026-04-10T11:44:52.727Z</atom:updated>
            <content:encoded><![CDATA[<h4>Frameworks built the agents. Orchestration runs them. Platforms scale them. Nobody’s governing them.</h4><p><strong>Disclaimer</strong>: The opinions expressed are solely my own and do not reflect the views or positions of my employer</p><p>Imagine your enterprise as a growing city, and AI agents as the workers, contractors, and service providers showing up to get things done.</p><p>Agent frameworks like LangChain and LlamaIndex are the toolboxes and raw materials — the hammers, wiring, and lumber. Useful, but a toolbox doesn’t build anything on its own.</p><p>Orchestration frameworks like LangGraph, AutoGen, and CrewAI are the construction crews. They decide who does what, in what order, and who hands off to whom. A crew can build a house.</p><p>Agent development platforms like Databricks, DataRobot, Vertex AI Agent Builder, and Bedrock Agents are the construction companies. They come with crews, equipment, safety gear, insurance, and a project manager. Faster, but you’re also locked into their way of working.</p><p>Any real city ends up using all three. A homeowner buys some tools, hires a crew for the kitchen, and brings in a bigger company for the foundation. That’s exactly what enterprises are doing with agents right now.</p><p>So what’s missing?</p><p>City Hall.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dyij79UpdZXLldtM4LIXZg.png" /></figure><h3>The Missing Layer</h3><p>At first, this all feels manageable. A few agents. A few workflows. A few teams.</p><p>Then scale hits. And visibility breaks down.</p><p>Enterprises can no longer clearly see what agents exist, what they are doing, which systems they touch, how much they cost, or who is responsible when something goes wrong.</p><p>A business stakeholder asks a simple question: <em>“What happened here?”</em></p><p>And no one has a clear answer.</p><p>That is the moment the conversation has to change. The problem is no longer just building agents. It is governing them.</p><h3>Why the Pattern Feels Familiar</h3><p>Every major platform shift goes through the same awkward stage.</p><p>APIs led to gateways, then management, then governance. Microservices led to service meshes, then observability, then control planes. Anyone who lived through those eras recognizes the shape of this one immediately — we’ve seen this movie before, and we know how it ends.</p><p>AI agents are walking the same road now. This is not a prediction. It is the next inevitable layer of enterprise maturity. New categories form when scale exposes what existing layers cannot solve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YiYWtfzFzq9YhwPxLid7qQ.png" /></figure><h3>Why Visibility Breaks Down</h3><p>At small scale, teams can manage agents with a spreadsheet and a good memory. A handful of workflows is still something a human brain can hold.</p><p>But scale changes that fast. Agents start getting built in different places by different teams. Some in one platform, some in another, some stitched together through orchestration layers that nobody outside that team really understands. There is no shared map. There is barely a shared vocabulary.</p><blockquote>And the surface area is growing fast. MCP is making it trivial for any agent to reach any tool — which is exactly why the question “what is this agent allowed to touch?” has to be answerable from somewhere other than the agent’s own code.</blockquote><p>Now imagine this.</p><p>One agent issues customer refunds. Another applies billing corrections. Both work exactly as designed. Both are individually well-behaved.</p><p>And one Tuesday afternoon, they both act on the same account within the same minute.</p><p>The customer ends up over-credited. The audit trail is split across two systems. Finance notices a week later. Nobody did anything wrong exactly — and that is what makes it hard to fix.</p><p>Now imagine the version nobody wants to talk about: an agent quietly touches a dataset it was never supposed to see, and three weeks later compliance is trying to reconstruct what happened from logs that don’t quite line up.</p><p>At small scale, that is a rare bug. At enterprise scale, it is a Tuesday.</p><p>This is the moment leaders stop asking, <em>“Can we build agents?”</em> and start asking, <em>“Can we govern them?”</em></p><h3>The Four Questions Every Enterprise Has to Answer</h3><p>A serious agent program has to answer four plain questions.</p><p><strong>Visibility — what is actually running?</strong> A real inventory of agents, workflows, the tools they call, and what they depend on.</p><p><strong>Control — what is allowed?</strong> Policies for permissions, data access, which tools an agent can touch, and what it can do at runtime.</p><p><strong>Accountability — who is responsible?</strong> Clear ownership. A name, a team, a business function. Someone who picks up the phone.</p><p><strong>Traceability — what happened?</strong> Logs, decisions, execution history. Enough of a trail that you can reconstruct a bad Tuesday weeks later.</p><p>Without these, agents may still work. But they are not ready for the enterprise. They are just ready for the demo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qlgRYI_vpcBqjwg2b_elRw.png" /></figure><h3>What City Hall Actually Looks Like</h3><p>Picture Monday morning with a control plane in place.</p><p>Someone opens a single view and sees the twenty-three agents that ran over the weekend — what they touched, what they cost, who owns each one, and which ones hit an exception. Two of them get flagged and paused on the spot because their behavior drifted overnight. One gets reassigned to a new owner because the original engineer moved teams last week. When finance walks over about a strange refund, the answer takes four minutes instead of four days. When an auditor asks which agents can reach customer data, there is a list, not a meeting.</p><p>That is the shift. Not magic. Just the quiet confidence of knowing what your AI did last night — and being able to act on it before the business even notices.</p><p>It is how you get governance, security, compliance, and something harder to name — operational trust. The feeling that you could, if someone asked, actually explain what your AI is doing.</p><p>Without it, you get the opposite. Contractors show up without permits. Two crews dig up the same street. Nobody remembers who approved the work. And when the bill arrives, everyone looks at everyone else.</p><p>That is chaos in a polite suit.</p><h3>Closing Thought</h3><p>AI agents are no longer experiments. They are sliding, quietly and quickly, into the enterprise operating model. And every operating model eventually needs governance.</p><p>The next layer in the stack is not another framework or platform feature. It is a control plane — the City Hall that brings order, accountability, and trust to the agentic enterprise.</p><p>Without it, the enterprise does not scale.</p><p>It sprawls.</p><blockquote>“If APIs exposed services,</blockquote><blockquote>and microservices scaled systems..</blockquote><blockquote>AI agents expose decisions.</blockquote><blockquote>And decisions must be governed.”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b3b34031464" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Family Plans, Not Individual Plans: Rethinking AI Rate Limits in Multi-Tenant Systems]]></title>
            <link>https://venkataphanipatelkhana.medium.com/family-plan-not-individual-plan-fixing-rate-limiting-for-multi-tenant-ai-agents-d48267a9da7a?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/d48267a9da7a</guid>
            <category><![CDATA[rate-limiting]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[api-gateway]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sat, 21 Mar 2026 19:08:32 GMT</pubDate>
            <atom:updated>2026-03-22T22:23:06.626Z</atom:updated>
            <content:encoded><![CDATA[<h4>Per-user limits look safe — but shared AI agents quietly drive up usage and costs.</h4><p><strong>Disclaimer</strong>: The opinions expressed are solely my own and do not reflect the views or positions of my employer</p><p><strong>TL;DR: </strong>Per-user rate limits fail in multi-tenant AI agent systems — shared agents bypass them, causing cost spikes and governance gaps. Shift to a “family data plan” model: sessions limit individuals, subscriptions cap total tenant usage. Ensures cost control, blast radius limits, isolation, and SLA alignment.</p><p>Most AI platforms think they have rate limiting under control.</p><p>They don’t.</p><p>In a multi-tenant agent world, per-user limits are surprisingly easy to bypass. A shared agent can rotate across sessions, stay under every per-user cap — and still quietly burn through millions of tokens.</p><p>Everything looks “within limits.”<br> Your bill says otherwise.</p><p>The issue isn’t enforcement.<br> It’s the mental model.</p><p><strong>If you’re not deep into AI systems, here’s the simple version:</strong></p><p>Imagine multiple people inside a company using the same AI assistant.<br> You limit how much each person can use it — but you don’t limit the total usage across the company.</p><p>Individually, everything looks controlled.<br> Collectively, usage (and cost) can spiral.</p><p>That’s the problem this post is addressing.</p><h3>The Problem: We’re Solving the Wrong Unit</h3><p>Traditional rate limiting was built for a simpler world:</p><ul><li>One user</li><li>One application</li><li>One backend</li></ul><p>So we limit by:</p><ul><li>user ID</li><li>API key</li><li>session</li></ul><p>And measure:</p><ul><li>requests per minute</li><li>tokens per hour</li></ul><p>This model works when each user is an isolated unit of consumption.</p><p>But modern AI systems don’t behave like that anymore.</p><p>Today’s reality looks more like this:</p><ul><li>Shared agents (planner, researcher, assistants)</li><li>Serving many users simultaneously</li><li>Deployed across multiple tenants</li><li>All traffic flowing through a central AI gateway</li></ul><p>In this model, the <strong>user is no longer the only unit of control</strong>.</p><p>The system is shared. The risk is shared. The cost is shared.</p><p>But the limits? Still per user.</p><p>That’s the gap.</p><h3>The Failure Mode Nobody Notices (Until the Bill Arrives)</h3><p>Let’s say you enforce:</p><ul><li>100K tokens per hour per session</li></ul><p>Looks reasonable.</p><p>Now imagine a misconfigured or compromised agent:</p><ul><li>It uses Session A → hits limit</li><li>Switches to Session B → continues</li><li>Then C, D, E…</li></ul><p>In a large tenant, this can scale fast.</p><p>No single session violates limits.<br> But aggregate usage explodes.</p><p><strong>If your limits don’t aggregate, your costs will.</strong></p><p>Example:</p><ul><li>500 sessions × 100K tokens/hour<br> = 50M tokens/hour</li></ul><p>And your system still says:<br> “Rate limiting is working as expected.”</p><p>Technically true. Practically useless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*no9DVerZZ7vJvwNYaCtCmA.png" /></figure><h3>The Shift: Think in “Family Plans,” Not “Individual Plans”</h3><p>A better mental model already exists — we just don’t apply it.</p><p>Think about mobile data plans.</p><h3>Individual Plan</h3><ul><li>One person</li><li>One data cap</li><li>Simple limit</li></ul><h3>Family Plan</h3><ul><li>Multiple people (lines)</li><li>Each can have controls</li><li>But all share a <strong>single data pool</strong></li></ul><p>No matter how many lines you add, you cannot exceed the total plan.</p><p>👉 The moment you move to shared agents, your unit of control is no longer the user — it’s the system boundary.</p><p>That’s the missing concept in AI systems:</p><p>👉 A <strong>shared consumption boundary</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lTHuqyTLNxe0NHKI6A-YBA.png" /></figure><h3>How This Looks in a Real System (Simplified)</h3><h3>1. Session = Individual Line</h3><p><em>(Think: one user’s interaction with the system)</em></p><ul><li>Represents a user interacting with an agent</li><li>Has its own limits:</li><li>tokens/hour</li><li>tokens/day</li></ul><p>Purpose:</p><ul><li>Prevent runaway loops</li><li>Protect individual usage</li></ul><h3>2. Subscription = Family Plan</h3><p><em>(Think: the overall plan for a tenant/customer)</em></p><ul><li>Represents a <strong>tenant + agent combination</strong></li><li>Defines a shared quota:</li><li>tokens/day</li><li>tokens/month</li><li>allowed models/tools</li></ul><p>Purpose:</p><ul><li>Enforce contract boundaries</li><li>Cap total consumption</li><li>Protect platform and cost</li></ul><h3>3. AI Gateway = Enforcement Layer</h3><p><em>(Think: the system that checks and allows/blocks usage)</em></p><p>Every request carries:</p><ul><li>Session ID → “which line”</li><li>Subscription ID → “which plan”</li></ul><p>On each request, the gateway checks:</p><ol><li>Session limits</li><li>Subscription limits</li></ol><p>Only if both pass → request is allowed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZNmzpOiIsWrwQdPvQv6vvw.png" /></figure><h3>A Concrete Example</h3><p>Take a tenant: <em>Acme</em><br> Using: <em>Planner Agent</em></p><h3>Subscription (Shared Plan)</h3><ul><li>10M tokens/day</li><li>200M tokens/month</li></ul><h3>Sessions (Lines)</h3><ul><li>Maria → session 1</li><li>John → session 2</li><li>Hundreds more users</li></ul><p>Each session might have:</p><ul><li>100K tokens/hour</li><li>500K tokens/day</li></ul><h3>What Happens</h3><ul><li>Maria can’t exceed her own limits</li><li>John can’t exceed his</li></ul><p>But more importantly:</p><p>👉 All sessions combined cannot exceed 10M tokens/day</p><p>Even if:</p><ul><li>1 user → fine</li><li>1,000 users → still bounded</li></ul><p>Adding more sessions does not increase total consumption.</p><p>That’s the key.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S7qtTWJpDtZYpj8FRla6yQ.png" /></figure><h3>In Simple Terms</h3><ul><li>Per-user limits → control individual behavior</li><li>Subscription limits → control total usage and cost</li><li>You need both</li></ul><p>Without the second, the first doesn’t protect you.</p><h3>This Is Not Just Rate Limiting — It’s a Control Layer</h3><p>This isn’t just about better rate limiting.</p><p>It’s about introducing a <strong>consumption control layer</strong> for AI systems — one that aligns usage, cost, and tenant boundaries in a way per-user limits never could.</p><p>This shift solves real enterprise problems:</p><ol><li><strong>Cost Predictability</strong> → No more surprise spikes from distributed usage.</li><li><strong>Blast Radius Control</strong> → A misbehaving agent is contained within a subscription boundary.</li><li><strong>Tenant Isolation</strong> → One tenant cannot indirectly impact platform stability or cost of others.</li><li><strong>Contract Enforcement</strong> → Usage aligns directly with what was sold.</li><li><strong>Governance for AI Systems</strong> → Foundational control, not just a safeguard.</li></ol><h3>Why Per-User Limits Alone Are Not Enough</h3><p>Per-user/session limits are still important — but on their own, they only solve:</p><ul><li>local misuse</li></ul><p>They do not solve:</p><ul><li>distributed consumption</li><li>multi-tenant scaling risk</li><li>cost aggregation</li></ul><p><strong>Per-user limits don’t control AI systems. They only localize failure.</strong></p><p>Without a shared quota layer, you’re effectively saying:</p><blockquote><em>“Everyone is limited individually, but together they can consume infinitely.”</em></blockquote><p>That’s not a limit.<br> That’s an illusion of control.</p><h3>The Pattern Going Forward</h3><p>The systems that scale safely will adopt this model:</p><ul><li><strong>Session limits at the edge</strong> → control behavior</li><li><strong>Subscription limits at the core</strong> → control cost and risk</li></ul><p>Both are required. Not optional.</p><h3>The One-Line Explanation</h3><blockquote><em>“We run AI usage like a family data plan.<br> Every user has their own line, but all usage rolls up to a shared tenant+agent plan.<br> No matter how many users you add, you can’t exceed that plan.”</em></blockquote><p>That’s the difference between:</p><ul><li>having rate limiting</li><li>having <strong>real control over AI consumption</strong></li></ul><h3>Final Thought</h3><p>Per-user rate limiting wasn’t designed for systems like this.</p><p>It was designed for a world where usage was linear, isolated, and predictable.</p><p>AI systems aren’t.</p><p>They are shared, distributed, and capable of scaling across thousands of sessions in seconds.</p><p>That changes the problem.</p><blockquote><em>Systems don’t fail one user at a time.<br> They fail in aggregate.</em></blockquote><p>And if your controls don’t operate at that level, they won’t protect you when it matters.</p><p>The real shift isn’t adding more limits.</p><p>It’s putting the boundary in the right place.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d48267a9da7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Concierge Agent at the Gate]]></title>
            <link>https://venkataphanipatelkhana.medium.com/the-concierge-agent-at-the-gate-55f810497619?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/55f810497619</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[zero-trust]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[identity]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sun, 25 Jan 2026 00:09:52 GMT</pubDate>
            <atom:updated>2026-01-25T03:20:58.316Z</atom:updated>
            <content:encoded><![CDATA[<h4>How AI Should Access MCP(Model Context Protocol) Tools — Not Your Keys</h4><p><strong>Disclaimer</strong>: The opinions expressed are solely my own and do not reflect the views or positions of my employer</p><p>TL;DR</p><ul><li>AI agents should never hold long-lived credential</li><li>Use a gateway/concierge to mediate tool access</li><li>Scope permissions per task, not per agent</li><li>MCP enables this pattern cleanly</li></ul><p><strong>From Theory to a Concrete Pattern</strong></p><p>In an earlier post, I argued that classic authentication and authorization — even with On-Behalf-Of (OBO) delegation — are not enough for autonomous, multi-tenant AI agents. That gap is what <strong>Session-Bound Agent Authorization (SBAA)</strong> addresses: every action must be evaluated in the context of a specific user, session, and risk state.</p><p>The fastest way to get breached in an MCP(Model Context Protocol) stack isn’t a clever prompt injection.<br> It’s giving your agent your keys instead of a pass at the gate.</p><blockquote><em>“I’ve seen agents authenticated correctly, authorized correctly — and still do the wrong thing because no one owned the session.”<br>“After working across API platforms and security controls, this pattern keeps repeating.”</em></blockquote><p>This article applies SBAA to a <strong>concrete, repeatable MCP architecture pattern</strong>: <em>the Concierge Agent at the Gate</em>. Instead of handing agents long-lived, over-privileged tokens, every action flows through an MCP-aware gateway that issues narrow, task-scoped passes to MCP tools.</p><p>Let the AI into the hotel.<br>Never give it the master keys.</p><h3>The Concierge Agent at the Gate (CAG) Pattern</h3><p>Imagine a high-security hotel:</p><ul><li><strong>You</strong> are the guest (the user).</li><li><strong>The AI agent</strong> is the concierge.</li><li><strong>The MCP gateway</strong> is the security desk at the main gate.</li><li><strong>MCP servers and tools</strong> are restricted areas: the kitchen, finance office, VIP lounge, vault.</li></ul><p>Nothing sensitive happens just because someone asks nicely.<br> Every action is controlled by <strong>who you are</strong>, <strong>who is acting for you</strong>, and <strong>what is allowed right now</strong>.</p><p>That’s the core of the CAG pattern:</p><blockquote><em>Agents are powerful — but the gate decides what they can do, per user, per task, per session.</em></blockquote><h3>A Quick Failure Scenario: When the Agent Has Your Keys</h3><p>Before describing the right model, it’s worth seeing the wrong one.</p><p>An AI agent is wired directly into MCP servers using a long-lived token representing a support engineer’s full access. The agent serves multiple customers across multiple tenants.</p><p>User A asks, “Show my invoices.”<br> Milliseconds later, User B — another tenant — asks the same thing.</p><p>Because the agent:</p><ul><li>Holds a single over-privileged token</li><li>Lacks session isolation</li><li>Calls MCP tools directly</li></ul><p>…it pulls the wrong data and returns Tenant A’s invoice to Tenant B.</p><p>No exploit. No malware. No prompt injection.<br> Just a shared, powerful token with no gate enforcing per-session, per-tool rules.</p><p>That’s what happens when the concierge has your master key instead of a scoped pass.</p><p>Now let’s fix it.</p><h3>Step 1: The Guest Proves Who They Are</h3><p>A guest approaches the concierge:</p><blockquote><em>“Can you send a meal to my room and print my invoice?”</em></blockquote><p>Before acting, the concierge asks for:</p><ul><li>A government ID</li><li>A room key card</li></ul><p>Only then does it treat the person as an authenticated guest with a specific identity and room.</p><p><strong>In MCP terms:</strong></p><ul><li>The agent prompts the user to authenticate via SSO/OIDC</li><li>MFA and device checks run as required</li><li>A user-bound identity and token are established</li></ul><p><strong>Key point:</strong><br> The agent never assumes who the user is. Identity is always proven first.</p><h3>Step 2: The Concierge Learns What the Guest Is Allowed to Do</h3><p>The guest continues:</p><blockquote><em>“Order dinner, upgrade my room, and print all my corporate invoices.”</em></blockquote><p>The concierge doesn’t guess. It consults the hotel’s policy book:</p><ul><li>Standard guests → limited room service</li><li>VIP guests → upgrades and lounge access</li><li>Corporate admins → billing history and invoices</li></ul><p><strong>In CAG terms:</strong></p><ul><li>The MCP owner defines scopes (e.g., read:invoices, order:room_service)</li><li>Scopes map explicitly to MCP tools and operations</li><li>The agent requests <strong>only the scopes needed for this task</strong></li></ul><p>The user can see — and consent to — what the agent is allowed to do <em>right now</em>.</p><p>No blanket access.<br> No “admin just in case.”</p><h3>Step 3: The Concierge Goes to the Gate</h3><p>Even with permission, the concierge doesn’t walk directly into the back-of-house.</p><p>Every sensitive area is behind the security desk.</p><p>To start any task, the concierge presents:</p><ul><li>Its own identity (agent principal)</li><li>The user it’s acting for</li><li>The approved scopes</li><li>The current session context</li></ul><p>This is the <strong>MCP gateway</strong>.</p><p>In the CAG pattern:</p><ul><li>Agents never call MCP servers directly</li><li>All agent → MCP traffic flows through the gateway</li><li>The gateway is the zero-trust boundary</li></ul><h3>Step 4: The Gate Verifies Both Agent and User</h3><p>Checking only the agent isn’t enough.<br> Checking only the user isn’t enough.</p><p>The gate evaluates <strong>both</strong>, together, in context:</p><ul><li>Is this agent trusted for this tenant?</li><li>Is it allowed to act for this user?</li><li>Does the user have permission for this tool?</li><li>Are limits, parameters, and timing acceptable?</li><li>What does current risk posture say?</li></ul><p>Only then does the gate issue a pass:</p><blockquote><em>“Concierge #27 may place one room-service order,<br> up to $50,<br> for Room 1402,<br> within the next 10 minutes.”</em></blockquote><p>Technically, this is a <strong>short-lived, task-scoped token</strong> bound to:</p><ul><li>Agent identity</li><li>User identity</li><li>Session context</li><li>Specific tool and action</li></ul><p>This is SBAA in practice:</p><blockquote>Is this agent, acting for this user, in this session, allowed to perform this action right now?</blockquote><h3>Step 5: The Back-of-House Does the Work</h3><p>The concierge presents the pass to the kitchen.</p><p>The kitchen staff don’t need:</p><ul><li>The guest’s ID</li><li>Their credit card</li><li>The concierge’s employment record</li></ul><p>They only check:</p><ul><li>Is the pass valid?</li><li>Has it expired?</li><li>Is it within limits?</li></ul><p>If yes, they do the work.</p><p><strong>In MCP terms:</strong></p><ul><li>MCP servers trust the gateway’s decision</li><li>Tools may add fine-grained checks</li><li>Execution happens with least privilege</li></ul><p>Crucially, tools never see raw user credentials or long-lived tokens.</p><h3>Step 6: Logging and Accountability</h3><p>Later, a guest disputes a charge.</p><p>Because this is a serious hotel, everything is traceable:</p><ul><li>Which concierge initiated the action</li><li>For which guest and room</li><li>Which area was accessed</li><li>What was done and when</li><li>Under which pass and policy</li></ul><p><strong>In CAG terms:</strong><br> Every action is logged as:</p><p><strong>agent → user → session → tool → resource → decision</strong></p><p>This is what real accountability looks like in multi-tenant systems.</p><p>User → Auth Gateway → MCP Concierge → Tool</p><p>User → Auth Gateway → MCP Concierge → Tool</p><h3>Mapping the Pattern to MCP Architecture</h3><p><strong>User (Guest)</strong></p><ul><li>Human identity via OIDC</li><li>Tenant and org context</li></ul><p><strong>Agent (Concierge)</strong></p><ul><li>Separate client identity</li><li>First-class principal</li><li>Explicit trust boundaries</li></ul><p><strong>Policies (Hotel Policy Book)</strong></p><ul><li>Scope definitions</li><li>Tool-to-scope mappings</li><li>Consent and least privilege rules</li></ul><p><strong>MCP Gateway (Security Desk)</strong></p><ul><li>Single entry point</li><li>Agent + user authorization</li><li>Session and risk evaluation</li><li>Pass issuance</li></ul><p><strong>Task-Scoped Tokens (Passes)</strong></p><ul><li>Short-lived</li><li>Action-specific</li><li>Minimal blast radius</li></ul><p><strong>MCP Servers and Tools (Back-of-House)</strong></p><ul><li>Execute real work</li><li>Trust gateway decisions</li><li>Never handle raw credentials</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-DkI0AA9UNmZCxVw6dcUpQ.png" /></figure><h3>Why This Pattern Matters: Not Your Keys</h3><p>As agents become autonomous and multi-tenant, the security question changes.</p><p>Not:</p><blockquote><em>“Is this agent allowed to call this MCP server?”</em></blockquote><p>But:</p><blockquote><strong><em>“Is this specific action, for this user, in this session, using this tool, allowed right now?”</em></strong></blockquote><p>The Concierge Agent at the Gate pattern answers that question — without neutering agents or exposing your systems.</p><h3>If You Do Nothing Else, Do This</h3><p>A practical checklist:</p><ul><li>Stop giving agents raw user tokens</li><li>Put a gateway in front of every MCP server</li><li>Issue short-lived, task-scoped passes</li><li>Separate agent and user identities</li><li>Log the full decision chain</li><li>Enforce policy at the gate, every time</li></ul><p>That’s how you keep agents useful, scalable, and safe.</p><p><strong>Let the concierge work.<br> Keep the keys at the gate.</strong></p><blockquote>If your AI agent needs your API keys, your architecture is already broken.</blockquote><p><strong>Related Reading:</strong><br>👉 Why OBO (On-Behalf-Of) Helps and Why Session Tokens Matter <a href="https://medium.com/@venkataphanipatelkhana/authentication-and-authorization-arent-enough-for-ai-agents-a29960e3d445">https://medium.com/@venkataphanipatelkhana/authentication-and-authorization-arent-enough-for-ai-agents-a29960e3d445</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55f810497619" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Enterprise AI Control Plane: Preventing Multi‑Million‑Dollar Failures Through Strong AI…]]></title>
            <link>https://venkataphanipatelkhana.medium.com/the-enterprise-ai-control-plane-8f36b409deef?source=rss-3f4e599fa0ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f36b409deef</guid>
            <category><![CDATA[ai-security]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[enterprise-ai]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[autonomous-agent]]></category>
            <dc:creator><![CDATA[Venkata Phani Patelkhana]]></dc:creator>
            <pubDate>Sun, 11 Jan 2026 18:12:34 GMT</pubDate>
            <atom:updated>2026-02-02T03:41:30.167Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Enterprise AI Control Plane: Preventing Multi‑Million‑Dollar Failures Through Strong AI Governance</h3><h4>Why Autonomous AI Requires a Central Command Hub for Safe Execution and Cost Control</h4><p><strong>Disclaimer</strong>: The opinions expressed are solely my own and do not reflect the views or positions of my employer</p><h3>TL;DR</h3><p>Autonomous AI doesn’t fail like traditional software. It fails <strong>silently, at scale, and across boundaries</strong> — tools, tenants, workflows, and time.</p><p>As enterprises move beyond copilots to <strong>autonomous agents</strong>, model accuracy and static guardrails aren’t enough. What’s missing is a <strong>runtime Enterprise AI Control Plane</strong>.</p><p>A real control plane is <strong>not dashboards</strong> or post‑hoc audits. It is a <strong>runtime enforcement + evidence system</strong> that governs:</p><ul><li><strong>Who an agent is</strong> (Agent Identity Mesh)</li><li><strong>Which session it operates under</strong> (Session Authority)</li><li><strong>Which tools/data it can access</strong> (MCP servers as gated routes)</li><li><strong>How policies are enforced in‑line before execution</strong></li><li><strong>What evidence is captured</strong> to prove why actions were allowed</li><li><strong>How risk + cost are bounded</strong> (rate limits, budgets, loop breakers)</li></ul><p>If you can’t answer <strong>in real time</strong>:<br> <strong>who did what, under which session, using which tools, at what risk and cost, with what evidence</strong> — <br> you don’t have AI governance. You have <strong>visibility theater</strong>.</p><h3><strong>A scenario you can’t dismiss as an “edge case”</strong></h3><blockquote>What if an AI agent in your <strong>supply chain system accidentally rerouted hundreds of shipments</strong> because session-level privileges weren’t properly enforced? Or what if another agent, through an MCP server, accessed tools it shouldn’t have?</blockquote><p>In enterprise AI ecosystems, agents operate faster than humans can intervene — and failures compound across systems before anyone realizes what happened.</p><p>AI isn’t “just software” anymore. It’s <strong>autonomous infrastructure</strong>. And autonomous infrastructure requires a <strong>control plane</strong> to maintain order, traceability, resilience, and economic boundaries.</p><p>This blog explains how to build that control plane end‑to‑end: identity, sessions, MCP routing, runtime monitoring, marketplace governance, evidence capture, economic controls, resilience testing, and proactive threat prevention.</p><h3>Why this needs a “v2” definition</h3><p>Many public explanations treat “control plane” as a governance layer across models, data, and AI interactions. Others focus on admin experiences around policy and auditability. That baseline is useful — but for <strong>autonomous agents</strong>, it’s incomplete.</p><p><strong>The v2 definition (the one that scales agents)</strong></p><p><strong>The Enterprise AI Control Plane is a runtime enforcement and evidence system that governs who an agent is, what session it operates under, which tools/data it can touch, how policy is enforced in‑line, and what proof is produced for every action — while keeping spend economically bounded.</strong></p><p>If your platform cannot answer:</p><blockquote><em>“Who did what, under which session constraints, using which tools, at what risk score, at what cost, with what evidence?”<br> …it’s not a control plane.</em></blockquote><h3>The Risks Executives Can’t Ignore</h3><p>Autonomous agent failures aren’t just technical incidents — they create business exposure:</p><ul><li><strong>Strategic risk:</strong> autonomous actions disrupt priorities and programs</li><li><strong>Regulatory exposure:</strong> violations under GDPR, SOX, or internal controls</li><li><strong>Operational impact:</strong> cascading failures, downtime, and bottlenecks</li><li><strong>Brand impact:</strong> silent incidents erode trust before detection</li></ul><p>Ignoring these risks isn’t optional — it’s a leadership vulnerability.</p><h3>Identity is the Flight Plan for Every Agent</h3><p>Picture a city full of <strong>autonomous delivery vehicles</strong> navigating busy streets. Each vehicle must:</p><ul><li>Take independent routes</li><li>Recalculate paths dynamically</li><li>Interact safely with other vehicles and infrastructure</li></ul><p>What keeps traffic safe?</p><ul><li>Not just the onboard software</li><li>Not just traffic rules</li><li>Not just surveillance cameras</li></ul><p>It’s <strong>dynamic traffic control</strong>.</p><p>Enterprise AI works the same way. Autonomous agents need <strong>identity and traceability first</strong>.</p><p><strong>Agent Identity Mesh</strong> is like <strong>vehicle registration and license plates</strong>:</p><ul><li>Actions tied to the agent itself</li><li>Linked to the user or tenant it represents</li><li>Bound to the session context</li></ul><p>Without a strong identity mesh:</p><ul><li>Policies cannot be enforced</li><li>Actions cannot be audited</li><li>Risks remain invisible</li></ul><blockquote><strong><em>Lesson I always share:</em></strong><em> No identity → no control. Every time.</em></blockquote><h3>Authorization and OBO: permissions aren’t enough</h3><p>Traffic controllers don’t just know a vehicle — they grant <strong>route-specific permissions</strong>.</p><p>In AI:</p><ul><li><strong>AuthN/AuthZ</strong> determines baseline permissions</li><li><strong>On-Behalf-Of (OBO)</strong> tokens attribute actions to the correct user</li><li>But <strong>session collisions</strong> and <strong>cross-tenant leaks</strong> can still occur</li></ul><h3>The missing piece: Session Authority</h3><p><strong>Session-level privileges</strong> prevent misfires the way a restricted lane prevents a vehicle from entering the wrong corridor — even if it has a valid identity.</p><p><strong>Session Authority binds</strong>:</p><ul><li>Agent ID</li><li>Tenant</li><li>Delegated user (if any)</li><li>Allowed tools</li><li>Allowed data classifications</li><li>Risk thresholds</li><li>Budget ceilings</li><li>Timebox + purpose</li></ul><p>Now the enforcement question becomes:</p><blockquote><em>“Is this action allowed </em><strong><em>in this session</em></strong><em>, for this tenant, with this risk score and remaining budget?”</em></blockquote><h3>MCP Servers: Smart Intersections and Corridors</h3><p>Identity is the flight plan, but agents still need <strong>safe routes</strong>.</p><p><strong>Model Context Protocol (MCP)</strong> servers act like <strong>smart intersections in a busy city</strong>:</p><ul><li>Define available tools and data</li><li>Enforce how agents interact with those tools</li><li>Serve as capability endpoints, not just integration points</li></ul><blockquote><strong><em>Pro tip:</em></strong><em> Treat MCP servers as both </em><strong><em>routing hubs and safety checkpoints</em></strong><em> — they are the backbone of controlled autonomy.</em></blockquote><h3>Observability: Your AI’s Real-Time Compass</h3><p>Even with identity and MCP routing, traffic isn’t left unmonitored. <strong>Observability acts as your AI compass</strong>, ensuring agents follow rules:</p><ul><li>Prompt evolution</li><li>Tool invocations</li><li>Retrieval context provenance</li><li>Policy outcomes and decisions</li><li>Behavioral drift across sessions</li></ul><p>Without observability, even authorized agents can <strong>silently break rules</strong>.</p><h3>Runtime Monitoring: Traffic Cameras in Action (plus automated interventions)</h3><p>Observability tells you what happened. <strong>Runtime monitoring enforces security posture in real time</strong>.</p><p>Agents can:</p><ul><li>Invoke sensitive tools</li><li>Access confidential data</li><li>Chain actions across trust boundaries</li></ul><p><strong>Runtime security capabilities that matter:</strong></p><ul><li><strong>Identity + session tracking:</strong> Every action tied to agent ID, user ID, tenant, session context</li><li><strong>Inline policy enforcement:</strong> Gateways enforce policies <strong>before</strong> tool execution</li><li><strong>Threat detection:</strong> Prompt injection, cross-session contamination, abnormal tool usage</li><li><strong>Streaming telemetry:</strong> Kafka/EventHub pipelines for real-time alerts</li><li><strong>Security posture scoring:</strong> Dynamic risk scoring to trigger escalation/quarantine/kill-switch</li></ul><h3>Evidence Ledger: audit logs are not proof</h3><p>Executives don’t just need logs — they need <strong>evidence</strong>.</p><p>An <strong>Evidence Ledger</strong> captures structured proof for every meaningful action:</p><ul><li>Who acted (agent identity + owner)</li><li>Under what constraints (session policy)</li><li>What context was used (provenance)</li><li>What tools were invoked (inputs/outputs)</li><li>Which policies were evaluated (and outcomes)</li><li>Whether a human approval occurred</li><li>Cost and latency boundaries</li><li>Final result classification (success / blocked / escalated)</li></ul><p><strong>Audit tells you what. Evidence tells you why it was allowed.</strong></p><h3>Marketplace: The Central Command Hub</h3><p>Just like a city traffic control center, the <strong>Marketplace acts as the command hub</strong>(not a catalog):</p><ul><li><strong>Governance hub:</strong> Central policy management for agents, tools, MCP endpoints</li><li><strong>Visibility layer:</strong> Dashboards for observability, compliance, risk scoring</li><li><strong>Compliance enforcement:</strong> Automated checks + evidence readiness</li><li><strong>Dynamic policy distribution:</strong> Push updated rules, rate limits, session policies</li><li><strong>Tool &amp; capability registry:</strong> MCP servers/tools published for controlled access</li><li><strong>Dependency graph:</strong> which agents depend on which tools (blast radius mapping)</li></ul><blockquote><strong><em>Note:</em></strong><em> The marketplace isn’t a catalog — it’s the </em><strong><em>nerve center of AI safety and control</em></strong><em>.</em></blockquote><h3>Rate Limiting: Lane Limits and Traffic Lights</h3><p>Traffic lights and lane limits prevent congestion and collisions. In AI:</p><ul><li><strong>Token-based rate limits</strong> control agent concurrency</li><li>Prevent overload, runaway costs, and cross-session contamination</li><li>Ensure <strong>safety, cost control, and compliance</strong></li></ul><h3>Economic governance: a safe agent that bankrupts you is still an outage</h3><p>Most organizations underestimate cost risk until their first runaway incident.</p><p>Economic safety belongs <strong>inside</strong> the control plane:</p><ul><li>token and concurrency limits (per agent/tenant/tool)</li><li>loop breakers (retry cycles, cyclic tool calls)</li><li>budget ceilings + spend attribution (BU/product/team)</li><li>risk‑based model routing (cheap models for low risk; strong models when needed)</li></ul><h3>Resilience engineering: emergency drills (adversarial testing included)</h3><p>Even with safeguards, unusual conditions happen:</p><ul><li>Traffic spikes</li><li>Misrouted tasks</li><li>Cross-agent interference</li><li>Malicious prompts</li></ul><p>Your control plane must include:</p><ul><li><strong>Adversarial prompt simulations</strong></li><li><strong>Tool misuse scenarios</strong></li><li><strong>Chaos testing for MCP dependencies</strong></li><li><strong>Failover drills and quarantine workflows</strong></li><li><strong>Behavioral drift tests</strong> across time and tenants</li></ul><h3>Threat policies: no-go zones and adaptive rules</h3><p>Cities have restricted lanes; airspace has no-fly zones.</p><p>Enterprise AI needs:</p><ul><li>Predefined prohibited actions (tool + data + workflow constraints)</li><li>Automatic enforcement at runtime</li><li>Continuous adaptation to new threat patterns</li></ul><h3>Proactive threat prevention (predict before you react)</h3><ul><li>Predictive risk scoring to identify high-risk sessions early</li><li>Drift detection to quarantine agents that change behavior</li><li>Continuous policy updates distributed via marketplace</li><li>Automated “kill switch” governance for urgent incidents</li></ul><h3>The Complete Control Plane: From Identity to Resilience</h3><p><strong>Mapping AI Components to Traffic Analogies</strong></p><p><strong>Identity &amp; Governance Layer</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*9v9Z-oRuD2UbpKoRE-v8Vw.png" /></figure><p><strong>Safety &amp; Resilience Layer</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/607/1*lm3i-8PYy3PkV-XSsEh8dA.png" /></figure><p>Every layer forms a <strong>causal chain of control</strong>, not a checklist.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m1BuVi79vaKzrvyYmu1Usw.png" /></figure><h3>KPIs that prove you have a real control plane</h3><p>If you want to make this operational — and executive-ready — measure it:</p><p><strong>Security &amp; compliance</strong></p><ul><li><strong>Session Boundary Integrity (%)</strong>: actions executed under valid session constraints</li><li><strong>Policy Coverage (%)</strong>: actions with recorded policy decisions</li><li><strong>Evidence Completeness (%)</strong>: actions with provenance + policy outcomes + tool IO</li></ul><p><strong>Reliability</strong></p><ul><li><strong>Containment time</strong>: time from anomaly → quarantine/kill-switch</li><li><strong>Tool blast radius score</strong>: impact size per tool incident</li></ul><p><strong>Economics</strong></p><ul><li><strong>Cost per governed outcome</strong> (not per call)</li><li><strong>Loop rate (%)</strong>: sessions triggering retry-loop breaker</li><li><strong>Budget compliance (%)</strong>: sessions staying within spend caps</li></ul><h3>Maturity model: from guardrails to governed autonomy</h3><p>Use this to benchmark where you are:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*1W3XOSR_ZdjZyaG_sw6L2g.png" /></figure><h3>Conclusion + Call-to-Action</h3><p>Autonomous agents operate faster, at scale, and across boundaries. Models alone aren’t enough.</p><p>Without a robust control plane, enterprise AI risks <strong>silent failures</strong> that leak data, disrupt operations, or violate compliance — and cost millions before anyone understands why.</p><p>A complete control plane requires:</p><ul><li><strong>Identity first</strong> (Agent Identity Mesh)</li><li><strong>Session-level authorization</strong> (Session Authority)</li><li><strong>MCP servers as safe routing</strong> (Tool Gateway + constraints/Guardrails)</li><li><strong>Observability + runtime monitoring</strong> (detect + intervene)</li><li><strong>Threat policies &amp; automated prevention</strong> (no‑go zones, adaptive rules, kill‑switches)</li><li><strong>Marketplace governance</strong> (command hub, policy distribution)</li><li><strong>Economic safety</strong> (rate limiting, spend caps, loop breakers)</li><li><strong>Resilience + adversarial testing</strong> (drills, simulations, drift hardening)</li><li><strong>Evidence ledger</strong> (proof, not just logs)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*go0AY2q_uirodoyEgVJ1qQ.png" /></figure><blockquote><strong><em>CTA:</em></strong><em><br> </em>From my experience, the most costly mistakes are silent and invisible. If your AI agents touch data, workflows, or money, start this quarter by mapping identities, enabling runtime monitoring, and enforcing session-level policies. Secure your AI control plane before silent failures impact your business.</blockquote><p>Treat your AI infrastructure like a <strong>city full of autonomous vehicles</strong>: without routing, monitoring, and governance, collisions are inevitable.</p><p><strong>Related Reading:</strong></p><p>👉 AI Agent Identity Mesh<a href="https://medium.com/@venkataphanipatelkhana/ai-agent-identity-the-missing-control-plane-in-enterprise-ai-security-048d2d137456">https://medium.com/@venkataphanipatelkhana/ai-agent-identity-the-missing-control-plane-in-enterprise-ai-security-048d2d137456</a><br>👉 Why OBO (On-Behalf-Of) Helps and Why Session Tokens Matter <a href="https://medium.com/@venkataphanipatelkhana/authentication-and-authorization-arent-enough-for-ai-agents-a29960e3d445">https://medium.com/@venkataphanipatelkhana/authentication-and-authorization-arent-enough-for-ai-agents-a29960e3d445</a></p><p>👉 MCP Gateway <a href="https://medium.com/@venkataphanipatelkhana/the-hidden-power-of-mcp-revolutionizing-enterprise-ai-with-mcp-servers-agent-ai-clients-and-the-c4d287151b96">https://medium.com/@venkataphanipatelkhana/authentication-and-authorization-arent-enough-for-ai-agents-a29960e3d445</a></p><p>👉 AI ecosystem Security</p><p><a href="https://medium.com/@venkataphanipatelkhana/the-silent-threat-inside-ai-ecosystems-why-mcp-and-agent-security-cant-wait-cb732d78829e">https://medium.com/@venkataphanipatelkhana/the-silent-threat-inside-ai-ecosystems-why-mcp-and-agent-security-cant-wait-cb732d78829e</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f36b409deef" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>