<?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 Abdulrafiu Izuafa on Medium]]></title>
        <description><![CDATA[Stories by Abdulrafiu Izuafa on Medium]]></description>
        <link>https://medium.com/@izuafa123abdulrafiu?source=rss-1a7b4f3d5358------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*K6pSAhie9txQDoriFI6YmA.jpeg</url>
            <title>Stories by Abdulrafiu Izuafa on Medium</title>
            <link>https://medium.com/@izuafa123abdulrafiu?source=rss-1a7b4f3d5358------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 17:13:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@izuafa123abdulrafiu/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[Approve = true: the weakest line in your Foundry agent]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/approve-true-the-weakest-line-in-your-foundry-agent-422ce8f47a3b?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/422ce8f47a3b</guid>
            <category><![CDATA[foundry]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sat, 21 Nov 2026 11:28:11 GMT</pubDate>
            <atom:updated>2026-11-21T11:28:11.627Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Your agent asked for permission. The tool has no idea what the person actually agreed to.</em></p><p>If I’m reviewing a Foundry agent that can take real actions, this is the first line I look for:</p><pre>McpApprovalResponse(approve=True, approval_request_id=req.id)</pre><p>That’s the human approval step in <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/model-context-protocol">Microsoft’s own MCP sample</a>. One boolean. Everything risky your agent does depends on it.</p><h3>How approval works in Foundry</h3><p>Foundry agents call tools through MCP. A tool is anything the agent can do, like send a payment, update a record or delete a file.</p><p>For risky tools, Foundry pauses and asks your app first. That’s on by default: require_approval is <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/mcp-authentication">set to always unless you change it</a>. Your app gets an mcp_approval_request, shows the user a message, and sends back an mcp_approval_response with approve=True. The tool runs.</p><p>Now look at what the MCP server actually receives.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kF0m9aSHh4-CLJl04JXSlA.png" /><figcaption><em>The MCP server gets a call. It never learns what the user heard.</em></figcaption></figure><p>It gets the call. Nothing else.</p><p>It doesn’t know who approved. It doesn’t know what message they were shown. It doesn’t know if they were shown anything at all. Your whole approval step lives in your app, and the tool just trusts that it happened properly.</p><h3>Let’s take Ada</h3><p>Ada works in finance. She’s blind and uses a screen reader set to short messages, because she’s fast and long sentences slow her down.</p><p>Her Foundry agent wants to send $500 to a new supplier account. Her app shows an approval prompt. Her screen reader reads it as:</p><p><strong>“Confirm transfer?”</strong></p><p>No amount. No account. She presses Enter.</p><p>The app sends approve=True. The $500 goes. The trace says the user approved.</p><p>Did she approve $500? Or did she approve two words?</p><h3>Four ways approve=true goes wrong</h3><p><strong>Nobody saw the prompt.</strong> The message never got announced or shown. The request timed out and your app applied its default. Do you know what your default is?</p><p><strong>They saw it, but not the important part.</strong> That’s Ada. A prompt without the amount isn’t a real approval.</p><p><strong>It got lost in translation.</strong> The agent writes in English and the user reads in another language. The amount and the payee are the two things that must come through right. Nothing checks that they did.</p><p><strong>The wrong person approved.</strong> A colleague taps Approve on Ada’s phone. The system still records Ada.</p><p>This isn’t only an accessibility issue. Anyone approving from a phone notification sees a cut-off message. Screen reader users just hit it first.</p><h3>What’s already solved</h3><p>Some of this has good answers already.</p><p><a href="https://github.com/Ishan2036924/open-action-consent">Open Action Consent</a> ties the approval to the exact details of the call. If the agent changes “2 people” to “20” after you approve, the call is blocked.</p><p>CIBA sends the approval to the person’s own phone with a short description. Auth0 has a <a href="https://auth0.com/blog/building-secure-ai-agents-microsoft-agent-framework-auth0-part-4-human-in-the-loop-approval">walkthrough using Microsoft Agent Framework</a>.</p><p>These answer two questions: who approved, and which call they approved.</p><p>Neither answers the third. <strong>What was the person actually told?</strong> The prompt is just text. Nobody checks that it contained the amount.</p><h3>The fix: three keys, checked at the tool</h3><p>This is how I’d design it. The tool, or a gateway in front of it, only runs a call when three things agree.</p><ol><li><strong>Who is asking.</strong> The user’s own identity, passed through to the tool. Microsoft calls this on-behalf-of.</li><li><strong>What the agent is allowed to do.</strong> The agent has its own identity and its own limits. It can only do what both the user and the agent are allowed to do.</li><li><strong>What the user agreed to, and was told.</strong> A small signed record. I call it a consent receipt.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*of7dGeYcpafeaxYLDoZ2Iw.png" /><figcaption><em>A tool call runs only when all three keys agree.</em></figcaption></figure><p>The third key is the part most Foundry agents are missing. The receipt holds:</p><ul><li>a fingerprint of the call’s details, so nothing can change after approval</li><li>the exact words the user was shown or heard</li><li>the language and display setting it was shown in</li><li>an expiry, and it can only be used once</li></ul><p>Then one rule makes it worth having. <strong>The tool declares which details matter.</strong> For a payment, that’s the amount and the account. If they’re not in the words the user got, the call doesn’t run.</p><pre>IMPORTANT = {&quot;transfer_funds&quot;: [&quot;amount&quot;, &quot;to_account&quot;]}</pre><pre>def check_receipt(tool, args, receipt):<br>    if receipt.details_fingerprint != fingerprint(args):<br>        return deny(&quot;the details changed after approval&quot;)<br>    for field in IMPORTANT.get(tool, []):<br>        if str(args[field]) not in receipt.words_shown:<br>            return deny(f&quot;the user was never shown the {field}&quot;)<br>    if receipt.used or receipt.expired():<br>        return deny(&quot;receipt already used or expired&quot;)<br>    return allow()</pre><p>Run Ada’s case through it. The words shown were “Confirm transfer?”. No amount. Denied.</p><p>That in check is deliberately simple. In production, &quot;$500.00&quot; and &quot;500&quot; need to match, so you send the amount as its own field next to the text. But even this version stops &quot;Confirm transfer?&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WyM7wA0UEzbCcfRhK45MsA.png" /><figcaption><em>Same two words in the user’s ear. Only one of these lets $500 go.</em></figcaption></figure><h3>What it can’t do</h3><p>It can’t prove the user understood. It can’t prove whose finger pressed the button. For high-value actions, step up to something only the user has, like a passkey on their own device.</p><p>What it does prove is that the amount and the account reached the user, in their language, for this exact call. That’s a lot more than true or false.</p><h3>Before you ship your Foundry agent</h3><ul><li>Search your code for approve=True. Every hit is a decision you made for your user.</li><li>Make every action you can’t undo reject on timeout, not approve.</li><li>Test your approval prompts with a screen reader on short messages. Listen to what it actually says.</li><li>Enforce the check in the tool, not in the agent’s instructions. Instructions can be talked around. Code can’t.</li></ul><p>Short prompts are fine. Prompts without the facts aren’t approvals.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=422ce8f47a3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The End of Software: Why We Need to Start Rearchitecting Applications for AI Agents]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/the-end-of-software-why-we-need-to-start-rearchitecting-applications-for-ai-agents-2dbc357a694c?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/2dbc357a694c</guid>
            <category><![CDATA[ai-agents-in-action]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sun, 01 Nov 2026 12:53:20 GMT</pubDate>
            <atom:updated>2026-11-01T12:53:20.222Z</atom:updated>
            <content:encoded><![CDATA[<p><em>For decades, we’ve built software that humans must learn to operate. The next generation of applications will increasingly operate on behalf of humans. This changes much more than the interface. It changes how we should architect software itself.</em></p><p>I think we’re approaching one of the most important architectural transitions in the history of software engineering.</p><p>And surprisingly, it has very little to do with whether AI can write better code.</p><p>It has to do with something we’ve accepted for decades: <strong>humans are responsible for learning how software works before they can get anything done.</strong></p><p>Think about the applications you use every day.</p><p>To accomplish a task, you open an application, navigate through menus, locate the appropriate feature, enter information, apply filters, and follow a series of steps someone else designed.</p><p>We have become so accustomed to this interaction model that we rarely question it.</p><p>But consider something as simple as understanding why a company’s revenue declined last month.</p><p>In a traditional analytics application, someone might need to open a dashboard, select the correct reporting period, compare figures, switch between reports, investigate anomalies, and interpret the results.</p><p>Now imagine an application where you simply ask:</p><p>“Why did our revenue decline last month?”</p><p>The system determines which data it needs, retrieves the relevant information, performs the analysis, and returns an explanation supported by evidence.</p><p>The interesting part isn’t that the second approach might be faster.</p><p>It’s that the human no longer needs to understand the application’s internal workflow.</p><p>We’ve spent decades designing interfaces that help people operate software.</p><p>AI agents introduce a different possibility: <strong>software that understands what people want to achieve and determines how to accomplish it.</strong></p><p>That distinction is going to affect far more than user experience.</p><p>It changes how applications expose their capabilities, how business logic is organized, how permissions are enforced, how workflows execute, and how systems communicate with one another.</p><p>And this is why I think developers need to start rearchitecting applications now.</p><p>Not because every application needs a chatbot.</p><p>But because the assumptions underlying much of today’s software architecture were made for a world where the primary user was a human clicking through an interface.</p><p>That assumption is changing.</p><h3>1. The problem with the way we’ve always built software</h3><p>For most of modern computing history, software interaction has followed a fairly predictable model.</p><p>A developer implements a collection of capabilities.</p><p>Those capabilities are exposed through an interface.</p><p>The user learns how to navigate that interface.</p><p>And the user performs the necessary operations to achieve an outcome.</p><p>Consider a financial management application.</p><p>The underlying business objective might be straightforward: identify unpaid invoices and follow up with customers.</p><p>But the application exposes that objective as several separate operations.</p><p>The user must locate the invoice module, select the appropriate records, apply filters, inspect customer information, draft follow-up messages, and initiate the next action.</p><p>The application may be well designed. The interface may be beautiful. Each individual feature might work perfectly.</p><p>Yet the user remains responsible for coordinating the workflow.</p><p>This reveals something interesting about conventional software.</p><p><strong>We’ve been optimizing the execution of individual operations rather than eliminating the need for humans to coordinate those operations.</strong></p><p>A faster dashboard is useful.</p><p>A better search interface is useful.</p><p>Reducing a process from twelve clicks to five is an improvement.</p><p>But these improvements preserve the same fundamental relationship.</p><p><strong>The human is still operating the software.</strong></p><p>What happens when the software can understand the objective behind those operations?</p><p>Instead of exposing a collection of unrelated features, the application could accept a goal:</p><p>“Find all invoices overdue by more than thirty days, prepare reminders, and show me the messages before sending them.”</p><p>The system could retrieve the invoices, apply the business rules, identify the relevant customers, prepare the messages, and request approval.</p><p>Notice what changed.</p><p>The underlying capabilities may be almost identical.</p><p>The application still needs invoice records, customer information, business logic, and messaging services.</p><p>But the responsibility for coordinating those capabilities has moved.</p><p>The user defines the outcome and the constraints.</p><p>The system handles more of the procedure.</p><p>That’s the architectural shift.</p><h3>The interface tax</h3><p>I find it useful to think of the effort involved in operating software as an interface tax.</p><p>It’s the additional work people perform because the application cannot directly translate their intentions into actions.</p><p>Every unnecessary navigation step contributes to that tax.</p><p>Every time someone exports information from one application just to upload it into another, they’re paying it.</p><p>Every time a business user needs to understand database structures, report names, or complex filtering rules to answer an ordinary question, they’re paying it.</p><p>Traditional user experience design attempts to reduce this tax by simplifying interfaces.</p><p>Agentic systems introduce the possibility of eliminating some of the underlying operations from the human workflow entirely.</p><p>And that’s a considerably bigger opportunity than simply adding conversational interfaces.</p><h3>2. We’ve seen this pattern throughout computing history</h3><p>Almost every major generation of computing has introduced a new abstraction between humans and machines.</p><p>Early computing required people to understand relatively low-level operations.</p><p>Command-line interfaces provided a more structured way to communicate with computers, although users still needed to remember commands and syntax.</p><p>Graphical user interfaces introduced windows, icons, menus, and pointers.</p><p>The web made applications accessible through browsers.</p><p>Mobile computing reorganized digital experiences around touch, portability, and context.</p><p>Cloud computing abstracted substantial portions of infrastructure management.</p><p>Each transition changed what the human needed to understand.</p><p>But there’s a detail we sometimes overlook.</p><p><strong>The underlying complexity didn’t disappear. It moved somewhere else.</strong></p><p>When cloud computing reduced the need for developers to manage physical servers, networking and infrastructure didn’t stop existing.</p><p>Those responsibilities moved into managed platforms and service abstractions.</p><p>Similarly, high-level programming languages didn’t eliminate machine instructions. They created more convenient ways of expressing computational behavior.</p><p>Agentic AI represents another potential abstraction.</p><p>Instead of requiring users to understand the procedures for operating an application, the system can interpret the goal and determine which operations are necessary.</p><p>We are moving toward a model where the human expresses <em>intent</em>, while software takes greater responsibility for <em>execution</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V1U2Llt3B2_fW1v51WsAmw.png" /><figcaption><em>Every major computing transition has changed which responsibilities humans must manage. Agentic computing extends that progression from infrastructure and interfaces toward workflow execution.</em></figcaption></figure><h3>3. The real transition is from procedures to outcomes</h3><p>Traditional applications are generally designed around explicitly defined interactions.</p><p>A button invokes a function.</p><p>A form collects structured input.</p><p>A menu exposes a set of operations.</p><p>The developer defines the possible paths through the application, and the user chooses which path to follow.</p><p>An agentic application introduces another layer.</p><p>The user describes an objective, and the system determines which capabilities are required to accomplish it.</p><p>Consider an e-commerce application.</p><p>Today, customers typically search for products, apply filters, open product pages, compare specifications, review delivery options, and complete checkout.</p><p>An agentic interaction could look like this:</p><p>“Find a lightweight laptop suitable for software development, under my budget, with at least 16GB RAM. Compare the best options and ask me before placing an order.”</p><p>The application now needs to interpret several things.</p><p>It must understand the user’s requirements.</p><p>It must retrieve products that satisfy those requirements.</p><p>It must compare relevant attributes.</p><p>It must account for availability, pricing, and delivery constraints.</p><p>And it must know that making a purchase requires explicit authorization.</p><p>The result is a different execution model.</p><p>The developer doesn’t necessarily know in advance which exact sequence of operations the user will request.</p><p>Instead, the developer provides structured capabilities, policies, and constraints that an agent can use to assemble an appropriate workflow.</p><p>This introduces an important distinction between two kinds of software behavior.</p><p><strong>Deterministic execution</strong> follows a predefined sequence of operations.</p><p><strong>Agent-directed execution</strong> allows a model to make some decisions about which operations to invoke, based on the request and the information obtained during execution.</p><p>These approaches aren’t mutually exclusive.</p><p>In fact, the most useful applications will likely combine them.</p><p>The agent can decide that an invoice needs to be retrieved.</p><p>But the actual invoice retrieval should be performed by a reliable, deterministic service.</p><p>The agent can propose a refund.</p><p>But refund eligibility, authorization, and payment execution should remain governed by explicit business rules.</p><p>The intelligence determines how to pursue the goal.</p><p>The application architecture determines what is permitted and how operations are executed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HR-uDcoQeS1EdOvCH0lNhg.png" /><figcaption><em>Agentic applications change the responsibility for assembling the workflow, not the need for reliable business logic.</em></figcaption></figure><h3>4. Why simply adding a chatbot to an existing application isn’t enough</h3><p>This is where I think many software teams misunderstand the transition.</p><p>They see improvements in language models and decide to add a conversational assistant to their existing product.</p><p>The implementation might look like this:</p><p>The user types a question.</p><p>The application sends the question to a language model.</p><p>The model returns a response.</p><p>The response appears in a chat interface.</p><p>That’s useful for some problems.</p><p>But it doesn’t necessarily make the application agentic.</p><p>The model may be capable of explaining how to perform an operation without being able to perform it.</p><p>For example, imagine a customer asks:</p><p>“Can you update my delivery address for order 4821?”</p><p>A basic chatbot might explain where to find the address settings.</p><p>A retrieval-based assistant might search documentation and provide the relevant instructions.</p><p>An agentic application could retrieve the order, verify whether the address is still editable, validate the new destination, calculate any delivery changes, request confirmation, and invoke the authorized update operation.</p><p>These systems have fundamentally different requirements.</p><p>The first two need access to information.</p><p>The third needs access to business capabilities.</p><p>That’s the important architectural difference.</p><p>If an application’s functionality exists only inside frontend components or tightly coupled user-interface workflows, an AI agent cannot easily access those capabilities.</p><p>Developers may attempt to solve this through browser automation, making the agent click through the same interface as a human.</p><p>That can work, especially when no direct integration is available.</p><p>But relying on browser automation as the primary integration strategy introduces fragility.</p><p>UI layouts change.</p><p>Elements move.</p><p>Sessions expire.</p><p>Workflows become difficult to verify.</p><p>And actions that were originally designed for human judgment may become accessible to automated execution without appropriate controls.</p><p>For applications we actually own, there’s a better approach.</p><p><strong>Expose business capabilities as stable, well-defined operations that can be consumed independently of the interface.</strong></p><p>That is where rearchitecting begins.</p><h3>5. The problem with UI-centric application architecture</h3><p>Many applications already have APIs.</p><p>So it’s reasonable to ask: if an application exposes APIs, isn’t it already prepared for agents?</p><p>Not necessarily.</p><p>There’s an important difference between having APIs and exposing meaningful business capabilities.</p><p>Consider an application with endpoints such as:</p><p>GET /customers</p><p>GET /invoices</p><p>PATCH /invoice/4821</p><p>POST /notifications</p><p>These endpoints expose resources.</p><p>But an agent trying to follow up on overdue invoices still needs to understand how those resources relate to business rules.</p><p>What qualifies as overdue?</p><p>Which invoices are disputed?</p><p>Which customers have opted out of reminders?</p><p>What happens if an invoice was paid five minutes ago?</p><p>Can a reminder be sent twice?</p><p>Who is authorized to initiate the action?</p><p>A collection of CRUD endpoints doesn’t automatically answer these questions.</p><p>This is why I think the next generation of application architecture needs to place greater emphasis on <strong>business capability boundaries</strong>.</p><p>Instead of exposing only low-level resource operations, applications should also expose operations that represent meaningful business intentions.</p><p>For example:</p><p>find_overdue_invoices</p><p>prepare_payment_reminders</p><p>validate_refund_eligibility</p><p>request_refund_approval</p><p>execute_approved_refund</p><p>Notice the distinction.</p><p>These are not simply database operations.</p><p>They’re controlled business capabilities.</p><p>Each operation can have explicit inputs, outputs, permission requirements, validation rules, and execution guarantees.</p><p>And importantly, the same capabilities can be used by multiple interfaces.</p><p>A web application can invoke them.</p><p>A mobile application can invoke them.</p><p>An automation service can invoke them.</p><p>And an AI agent can invoke them.</p><p>The underlying business logic no longer needs to be organized around the assumptions of one particular user interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_61-g0Mj7-E4E7igI-vFTg.png" /><figcaption><em>The goal isn’t to replace existing interfaces. It’s to separate business capabilities from the interfaces through which they’re accessed.</em></figcaption></figure><h3>6. The architectural principle: capabilities should exist independently of their interfaces</h3><p>This is probably the most important engineering takeaway.</p><p>Historically, teams often organize software development around screens and features.</p><p>A customer management page.</p><p>An invoice approval screen.</p><p>An analytics dashboard.</p><p>A reporting module.</p><p>A configuration page.</p><p>These are useful ways of organizing product development, but they can also encourage business logic to become closely associated with specific interfaces.</p><p>Agent-ready systems benefit from a different separation of concerns.</p><p>The presentation layer should express and collect user interaction.</p><p>The domain layer should implement business capabilities and invariants.</p><p>The execution layer should coordinate operations.</p><p>The policy layer should determine what each actor is authorized to do.</p><p>And the integration layer should provide reliable access to external systems.</p><p>This separation isn’t an entirely new invention.</p><p>Domain-driven design, hexagonal architecture, service-oriented architecture, and API-first development have advocated related ideas for years.</p><p>What’s changing is the importance of those principles.</p><p>When the only consumer is your own web interface, tightly coupled implementation choices may remain hidden.</p><p>Once an agent becomes another consumer of the system, those assumptions become much more visible.</p><p>The agent cannot safely depend on undocumented frontend behavior.</p><p>It needs explicit capabilities.</p><p>It needs clear input schemas.</p><p>It needs reliable responses.</p><p>It needs to know whether an operation succeeded, failed, or requires approval.</p><p>It needs to understand whether an operation is reversible or idempotent.</p><p>And it needs the execution environment to enforce authorization independently of the model.</p><p>In other words, <strong>agentic software makes architectural discipline more important, not less.</strong></p><p>A system that exposes well-defined domain capabilities is easier to integrate with agents.</p><p>A system whose capabilities are buried inside interfaces becomes much harder to adapt.</p><p>This is why rearchitecting matters even for teams that aren’t planning to deploy an AI agent immediately.</p><p>They’re preparing the application to support additional interaction models without rebuilding the business logic for each one.</p><h3>7. What an agent-ready architecture actually looks like</h3><p>Let’s make this concrete.</p><p>An agent-ready application doesn’t necessarily require a large collection of autonomous agents.</p><p>It requires an architecture in which user intent can be translated into authorized operations without bypassing the application’s business rules.</p><p>A useful reference architecture has several layers.</p><h3>The interaction layer</h3><p>This is where requests originate.</p><p>It might be a website, mobile application, messaging platform, voice interface, or another software agent.</p><p>The important point is that the interaction layer shouldn’t own all the business logic.</p><p>Its responsibility is to communicate the user’s objective, context, and constraints.</p><h3>The agent runtime</h3><p>This layer interprets the request and decides which capabilities may be needed.</p><p>It can select tools, maintain task state, inspect intermediate results, and determine whether additional steps are required.</p><p>The runtime might use an orchestration framework or a managed agent service.</p><p>But the framework itself is not the architecture.</p><p>The architecture is defined by the responsibilities and boundaries around the model.</p><h3>The capability layer</h3><p>This exposes the operations an agent can request.</p><p>Examples include retrieving invoice information, creating a support ticket, searching approved documents, or preparing a customer notification.</p><p>Each capability should have a defined contract.</p><p>The model should not need to know how the entire application is implemented internally.</p><h3>The policy and authorization layer</h3><p>This is responsible for deciding whether the requested operation is permitted.</p><p>It evaluates the user’s identity, the agent’s authority, the targeted resource, and the operation being requested.</p><p>Importantly, these checks must happen in trusted application code or an appropriate authorization service.</p><p>They cannot be delegated solely to a language model.</p><h3>The domain and data layer</h3><p>This contains the actual business functionality.</p><p>Databases, semantic models, domain services, transaction processors, and external integrations remain responsible for executing operations correctly.</p><p>The agent doesn’t replace these systems.</p><p>It provides another way to coordinate their capabilities.</p><h3>The execution and observability layer</h3><p>This manages operational concerns such as task persistence, retries, timeouts, rate limits, audit records, monitoring, and recovery.</p><p>It becomes especially important for long-running or consequential workflows.</p><p>A request that takes thirty seconds is different from one that must wait for a manager’s approval before continuing.</p><p>The application needs to handle both cases reliably.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4g5ajHQqKiitZ5CBUpcdsQ.png" /><figcaption><em>An agent should decide which capabilities are useful. Trusted application components should decide whether and how those capabilities execute.</em></figcaption></figure><h3>8. MCP and A2A are signs of a larger architectural change</h3><p>One reason the shift toward agent-ready architectures is becoming more practical is the development of standardized interaction protocols.</p><p>Two important examples are the Model Context Protocol and the Agent2Agent protocol.</p><p>They solve different problems.</p><h3>Model Context Protocol: connecting agents to capabilities</h3><p>The <a href="https://modelcontextprotocol.io/">Model Context Protocol (MCP)</a> provides a standardized way for applications using language models to interact with external tools and resources.</p><p>Think about the integration problem.</p><p>A developer wants an agent to retrieve information from a CRM, query an analytics system, interact with project management software, and search a document repository.</p><p>Without standardization, each integration may require custom discovery and invocation logic.</p><p>MCP provides a common protocol for exposing capabilities such as tools, resources, and prompts.</p><p>An MCP server can advertise a tool, describe its input schema, and provide a standardized invocation mechanism.</p><p>For example, a financial application might expose a tool named get_customer_balance.</p><p>The model can discover the capability and supply structured arguments.</p><p>But the application must still authenticate the request, enforce resource-level authorization, and return a reliable result.</p><p>MCP does not eliminate those responsibilities.</p><p>It standardizes part of the interaction between the agent application and external capabilities.</p><p>The protocol has also continued evolving. The July 2026 MCP specification introduced changes including a stateless protocol core, authorization improvements, and additional extensibility mechanisms.</p><p>This matters because we’re beginning to establish common integration contracts for a class of software consumers that didn’t exist at the same scale a few years ago.</p><h3>Agent2Agent: connecting agents to other agents</h3><p>The <a href="https://a2a-protocol.org/">Agent2Agent (A2A) protocol</a> addresses a related but different problem.</p><p>Instead of primarily exposing a tool, A2A supports communication between independent agent systems.</p><p>Imagine a procurement agent that needs assistance from an inventory agent.</p><p>The procurement agent shouldn’t necessarily require access to the inventory agent’s internal tools, context, or implementation.</p><p>It could delegate a task to the other agent through an interoperable protocol.</p><p>A2A supports concepts such as capability discovery, task management, communication, and exchanging resulting artifacts.</p><p>This is different from invoking a simple function.</p><p>The remote agent may perform its own internal sequence of operations before returning a result.</p><p>That introduces another architectural consideration.</p><p>Software services may increasingly expose both conventional APIs and higher-level agent capabilities.</p><p>However, that doesn’t mean every system needs A2A or that every API should immediately become an MCP server.</p><p>Use the protocol that fits the integration problem.</p><p>A conventional API is often sufficient for direct application-to-service communication.</p><p>MCP becomes useful when standardized model-facing tool integration adds value.</p><p>A2A becomes relevant when independently managed agents genuinely need to collaborate.</p><p>The important design principle is to avoid coupling your core business capabilities to any one agent framework or communication protocol.</p><p>Protocols will evolve.</p><p>Your domain logic should remain usable independently of them.</p><h3>9. Security becomes an execution problem, not just an access problem</h3><p>This is where agentic architecture becomes significantly more challenging.</p><p>Traditional applications usually receive relatively explicit user instructions.</p><p>A person clicks a button to approve an invoice.</p><p>The application checks permissions and processes that operation.</p><p>In an agentic system, the user may authorize a broader objective.</p><p>The system then decides which intermediate actions are needed to achieve it.</p><p>That introduces a new kind of risk.</p><p>A language model may misunderstand the request, select an inappropriate tool, or encounter malicious instructions embedded in retrieved information.</p><p>And once tools are available, an incorrect interpretation can become an incorrect action.</p><p>Consider an agent processing customer emails.</p><p>It retrieves a message that includes an instruction telling it to export all customer records to an external address.</p><p>The email is task data.</p><p>It is not an authorized instruction from the user.</p><p>But if the application fails to enforce the distinction between untrusted content and executable authority, the agent could attempt an unauthorized operation.</p><p>This is one reason prompt injection is particularly concerning in tool-using systems.</p><p>The <a href="https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html">OWASP AI Agent Security guidance</a> identifies risks including tool abuse, privilege escalation, data exfiltration, excessive autonomy, and cascading failures.</p><p>The architectural answer is not simply to write a stronger system prompt.</p><p>We need explicit trust boundaries.</p><p>A model can propose an action.</p><p>It must not become the sole authority deciding whether that action is permissible.</p><h3>Separate planning from execution</h3><p>The agent runtime may decide that a payment should be initiated.</p><p>But a trusted payment service should determine whether the transaction is valid.</p><p>The same principle applies to sending emails, modifying customer records, deleting data, or changing system configurations.</p><h3>Preserve identity and authority</h3><p>An agent acting on behalf of a user should not automatically inherit broad backend administrator privileges.</p><p>Where supported, delegated authentication and on-behalf-of flows allow downstream systems to evaluate access using the user’s permitted scope.</p><p>Other scenarios may use explicitly scoped application identities.</p><p>Microsoft’s <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/agent-identity">Foundry agent identity guidance</a> discusses these distinctions and the use of narrowly scoped identities for downstream access.</p><h3>Treat tools as security boundaries</h3><p>Tool definitions should expose only the operations necessary for the intended workflow.</p><p>An agent that needs to retrieve invoices should not receive unrestricted database modification privileges.</p><p>An agent that prepares messages shouldn’t automatically be authorized to send them.</p><p>This is the <strong>principle of least privilege </strong>applied to model-directed execution.</p><h3>Make consequential actions reviewable</h3><p>For significant operations, the application should present the proposed action, its parameters, and relevant evidence before execution.</p><p>And the approval should correspond to the exact action being performed.</p><p>A generic confirmation such as “allow this agent to proceed” is much weaker than approving a particular transfer to a specified recipient for a specified amount.</p><p>As agents become more capable, precise authorization becomes more important.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9de_8q27kSKZI6UtdyjY-Q.png" /><figcaption><em>An AI agent can recommend what should happen. Trusted application systems must remain responsible for what is allowed to happen.</em></figcaption></figure><h3>10. Rearchitecting also means redesigning how workflows execute</h3><p>There’s another engineering problem that isn’t discussed enough.</p><p>Traditional request-response applications are often built around operations that complete relatively quickly.</p><p>A request arrives.</p><p>A controller invokes business logic.</p><p>A response is returned.</p><p>Agentic workflows can be considerably more complicated.</p><p>An agent might need to retrieve information, call several tools, wait for an approval, retry an operation, and continue after the user returns hours later.</p><p>That requires more than a conversational session.</p><p>It requires durable task execution.</p><p>Consider an expense approval workflow.</p><p>An employee asks an agent to submit an expense claim.</p><p>The agent retrieves the receipt, extracts the necessary information, identifies the appropriate expense category, validates the details, and submits the request.</p><p>The claim then requires manager approval.</p><p>The manager may not respond immediately.</p><p>The application must preserve the workflow state and resume correctly when the approval arrives.</p><p>If the agent’s execution process terminates while waiting, the task must not simply disappear.</p><p>This is why agentic systems often need explicit task identifiers, persistent workflow state, queues, execution histories, and recovery mechanisms.</p><h3>Idempotency becomes critical</h3><p>Imagine an agent submits a refund request.</p><p>The API processes the refund, but the network connection fails before the response reaches the agent.</p><p>The agent doesn’t know whether the operation succeeded.</p><p>If it blindly retries, it might attempt a duplicate refund.</p><p>This is a distributed systems problem, not a language model problem.</p><p>The refund operation should support an idempotency mechanism, such as a unique operation identifier that prevents the same logical request from being processed twice.</p><h3>Recovery must be designed deliberately</h3><p>Some operations can be retried safely.</p><p>Others cannot.</p><p>Some workflows can be rolled back.</p><p>Others need compensating actions.</p><p>An agent that books travel, for example, may be coordinating several independent services.</p><p>If the flight booking succeeds but the hotel booking fails, the application needs an explicit recovery policy.</p><p>Should it retry the hotel?</p><p>Request user intervention?</p><p>Attempt to cancel the flight?</p><p>Those decisions shouldn’t be improvised without limits.</p><p>They need to reflect the business rules and the user’s authorization.</p><h3>Execution must have boundaries</h3><p>Every agentic workflow should have reasonable limits on time, cost, tool calls, retries, and the kinds of actions it can perform.</p><p>Without them, a malfunctioning execution loop could repeatedly call expensive services or continue acting after the original task has become impossible.</p><p>The lesson is straightforward.</p><p><strong>Adding an agent to an application doesn’t remove distributed systems complexity. It introduces new ways for that complexity to surface.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J1C145pofgdz8cLZ9UH-Mg.png" /><figcaption><em>Agentic systems need durable execution, not just conversational reasoning.</em></figcaption></figure><h3>11. Your data architecture becomes part of your agent architecture</h3><p>A powerful language model cannot compensate for poorly defined business data.</p><p>This becomes obvious when an agent is asked to answer analytical questions.</p><p>Suppose a user asks:</p><p>“What was our revenue growth last quarter?”</p><p>The model might understand the sentence perfectly.</p><p>But what does revenue mean in this organization?</p><p>Gross sales?</p><p>Recognized revenue?</p><p>Net revenue after refunds?</p><p>Does the quarter refer to the calendar year or the company’s fiscal year?</p><p>Which currencies should be used?</p><p>Which subsidiaries are included?</p><p>The model needs reliable business definitions.</p><p>Without them, it may generate a technically valid query that produces a misleading answer.</p><p>This is why semantic models, metadata, data quality, and governed access remain fundamental to enterprise AI.</p><p>In Microsoft Fabric, for example, data agents can provide natural-language access to supported data sources and semantic models.</p><p>But the value depends on the quality of the underlying data and its definitions.</p><p>An agent querying a well-governed semantic model has a much better foundation than one trying to infer business meaning from undocumented database columns.</p><p>The architectural implication is important.</p><p><strong>Agent readiness is not only about exposing APIs. It’s also about making the meaning of your data explicit.</strong></p><p>That involves documenting metrics, relationships, units, business rules, data provenance, and access restrictions.</p><p>It also means preserving security boundaries.</p><p>An agent must not use a privileged connection to retrieve information that the requesting user would normally be prohibited from accessing.</p><p>Row-level security, tenant isolation, and other data controls still apply.</p><p>Natural-language access shouldn’t become a way to bypass established governance.</p><p>And just as importantly, the agent should distinguish between facts retrieved from data and conclusions it generates.</p><p>If a query shows that revenue declined by 12%, that’s an observed result.</p><p>If the agent claims that a specific operational problem caused the decline, it needs additional supporting evidence.</p><p>A system that answers confidently without making that distinction can be dangerous in business decision-making.</p><h3>12. The economics of software will change when the unit of interaction becomes an outcome</h3><p>There’s also a product and commercial implication.</p><p>Today, many software products are organized around features, seats, subscriptions, and access to interfaces.</p><p>Agentic systems introduce another dimension: completed work.</p><p>A user may care less about how many features an application exposes and more about how reliably it can accomplish an objective.</p><p>Consider two financial applications.</p><p>One provides twenty reporting dashboards.</p><p>The other provides access to the same underlying information but can also investigate discrepancies, prepare reconciliations, and generate explanations.</p><p>If those capabilities are accurate, authorized, and reliable, the second product may deliver more useful outcomes even if its interface is simpler.</p><p>This could change how some software products compete.</p><p>The differentiator may become the quality of the underlying capabilities, data access, workflow reliability, and trust controls, rather than the sheer number of screens.</p><p>However, there is a trade-off.</p><p>Agentic execution has costs.</p><p>Model inference, tool calls, data retrieval, orchestration, and verification all consume resources.</p><p>An agent that uses five model calls and several APIs to perform a task may be more expensive than a deterministic workflow that accomplishes the same thing directly.</p><p>This means developers need to evaluate the cost of achieving an outcome, not just the cost of an individual model request.</p><p>A useful engineering measure is:</p><p><strong>Cost per successfully completed task = Total execution cost / Number of successfully completed tasks.</strong></p><p>The same logic applies to latency.</p><p>If an agent takes forty seconds to complete a task that a conventional workflow handles in two seconds, the more intelligent interface may actually provide a worse experience.</p><p>The goal isn’t to maximize the use of AI.</p><p>It’s to minimize unnecessary effort while preserving correctness, reliability, and sensible cost.</p><p>Some tasks will benefit from agents.</p><p>Others will benefit from ordinary automation.</p><p>And many will benefit from a combination.</p><h3>13. Why developers need to start rearchitecting now</h3><p>The strongest reason to start preparing isn’t that every application will suddenly become autonomous.</p><p>It’s that architecture is difficult to change once its assumptions become deeply embedded.</p><p>A system built around tightly coupled frontend workflows may require substantial restructuring before an agent can safely access its capabilities.</p><p>A system with inconsistent authorization patterns may struggle to enforce delegated access.</p><p>A platform with undocumented business logic may expose tools that produce unpredictable outcomes.</p><p>And an application without reliable execution histories may be difficult to debug once its workflows become dynamic.</p><p>These issues don’t disappear when a better language model becomes available.</p><p>They become more visible.</p><p>That’s why I think developers should begin preparing the architecture before deciding how much autonomy to introduce.</p><p>The immediate objective should be to make software capabilities reusable, secure, and independently accessible.</p><p>A well-structured application can continue serving human users through its existing interface while gradually adding agentic capabilities.</p><p>A poorly structured application may need extensive changes just to support one reliable agent.</p><p>This isn’t about rewriting every application from scratch.</p><p>In fact, for most established systems, a gradual approach is more sensible.</p><h3>14. How to rearchitect an existing application for agentic AI</h3><p>Let’s use a practical example.</p><p>Imagine a customer support platform with a conventional interface.</p><p>Agents working in the support department manually search for customers, retrieve orders, check refund eligibility, create tickets, and communicate with customers.</p><p>The company wants to introduce an AI agent that can assist with these tasks.</p><p>The wrong starting point would be to connect a language model to the entire database and allow it to decide which records to modify.</p><p>A better approach is to rearchitect progressively.</p><h3>Step 1: Identify the actual business outcomes</h3><p>Start by examining the tasks users are trying to complete.</p><p>Not the pages they visit.</p><p>Not the buttons they click.</p><p>The outcomes.</p><p>For a support system, these might include resolving a delivery complaint, preparing a refund, updating a customer address, or retrieving order information.</p><p>Map the existing manual workflows and identify which steps are deterministic, which require judgment, and which require approval.</p><h3>Step 2: Extract domain capabilities from interface-specific logic</h3><p>Suppose the refund eligibility rules currently live inside a controller used by the web application.</p><p>Move that logic into a reusable domain service.</p><p>The web application should call the service.</p><p>The agent’s tool layer should call the same service.</p><p>This prevents the business rules from being duplicated.</p><p>It also means changes to the refund policy apply consistently regardless of which interface initiates the request.</p><h3>Step 3: Design explicit capability contracts</h3><p>Each operation should have a clear purpose and structured inputs and outputs.</p><p>Consider prepare_refund.</p><p>Its inputs might include an order identifier, requested amount, reason, and requesting user context.</p><p>Its response might include the eligibility result, maximum refundable amount, required approval level, and any restrictions.</p><p>Separate this from execute_refund, which performs the actual financial transaction.</p><p>That separation allows the agent to investigate and prepare an operation without automatically receiving authority to execute it.</p><h3>Step 4: Introduce a controlled tool gateway</h3><p>Expose selected domain capabilities through a tool or API gateway.</p><p>The gateway should validate arguments, authenticate requests, enforce permissions, record execution metadata, and return structured results.</p><p>If MCP is useful for the intended consumers, expose appropriate tools through an MCP server.</p><p>But the core business operations should remain independent of the MCP implementation.</p><p>This avoids coupling the application to a particular agent framework or protocol.</p><h3>Step 5: Add the agent runtime</h3><p>Once reliable capabilities exist, introduce a model-driven execution layer.</p><p>Start with a narrow use case.</p><p>For example, the agent might retrieve order status and explain delivery delays.</p><p>Initially, it may only have read-only permissions.</p><p>As confidence grows, it can be allowed to prepare actions such as refund requests or address changes.</p><p>Actual execution can remain subject to explicit approval.</p><h3>Step 6: Add evaluation before expanding autonomy</h3><p>Create a test set containing realistic user requests.</p><p>Include straightforward cases, ambiguous instructions, missing information, conflicting records, permission restrictions, malicious input, and tool failures.</p><p>Measure whether the agent selects the right operations, returns accurate information, respects authority boundaries, and stops when it should.</p><p>This is different from evaluating whether its final response sounds convincing.</p><p>A well-written explanation of an incorrectly executed refund is still a failed task.</p><h3>Step 7: Expand gradually</h3><p>Only after the workflow is reliable should the team consider more complex tasks or greater autonomy.</p><p>This approach allows the existing application to continue operating while agent-accessible capabilities are introduced incrementally.</p><p>It also reduces the risk of placing too much responsibility on a system before its operational behavior is understood.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l9fPceMr0cRdMH7-Zkd0bg.png" /><figcaption><em>Rearchitecting for agents should be an incremental modernization process, not an uncontrolled rewrite.</em></figcaption></figure><h3>15. Not every application needs an autonomous agent</h3><p>This is an important distinction.</p><p>The existence of powerful language models doesn’t mean every workflow should be controlled by one.</p><p>Sometimes deterministic automation is the better solution.</p><p>If a process follows a small number of predictable steps, ordinary application code may be faster, cheaper, and easier to test.</p><p>If the problem involves a user asking questions about documents, retrieval and a single model response may be sufficient.</p><p>If the task requires interpreting ambiguous goals, selecting tools dynamically, and adapting to unexpected results, an agent may be more appropriate.</p><p>A useful distinction appears in Anthropic’s <a href="https://www.anthropic.com/research/building-effective-agents">Building Effective Agents</a>, which separates predefined workflows from systems where the model dynamically directs the execution process.</p><p>The general engineering principle is to begin with the simplest architecture that solves the problem.</p><p>Adding more agents does not automatically make a system more intelligent.</p><p>Every additional agent can introduce communication overhead, new failure points, increased latency, and additional security boundaries.</p><p>A single well-designed agent connected to reliable capabilities may be considerably more effective than five agents repeatedly exchanging uncertain information.</p><p>Similarly, some applications should retain rich graphical interfaces.</p><p>Image editing, visual design, complex data exploration, and safety-critical operations can benefit from direct manipulation and deterministic controls.</p><p>The future isn’t necessarily software without screens.</p><p>It’s software where the user doesn’t have to operate unnecessary screens just to accomplish an objective.</p><p>The interface should match the task.</p><p>And the architecture should support more than one interaction model.</p><h3>16. How we measure good software needs to change</h3><p>If applications increasingly focus on outcomes, then the way we evaluate them must evolve.</p><p>Traditional product analytics often emphasize interactions.</p><p>Page views.</p><p>Sessions.</p><p>Feature engagement.</p><p>Time spent in an application.</p><p>Those metrics can be useful, but they don’t always reveal whether the user achieved what they wanted.</p><p>Imagine one application requires someone to spend ten minutes navigating multiple pages to complete a task.</p><p>Another completes the same task correctly in thirty seconds.</p><p>The first may generate more interaction events.</p><p>But that doesn’t mean it creates more value.</p><p>For agentic systems, we need to measure successful task completion.</p><p>And we need to be precise about what success means.</p><p>Did the system accomplish the requested outcome?</p><p>Was the result correct?</p><p>Were the user’s permissions respected?</p><p>Did the system call appropriate tools?</p><p>Was the result supported by evidence?</p><p>How much human intervention was required?</p><p>How long did it take?</p><p>How much did it cost?</p><p>And what happened when the task failed?</p><p>These metrics should be evaluated together.</p><p>A system that completes a task quickly but incorrectly is not better.</p><p>A system that saves time while occasionally taking unauthorized actions is not better.</p><p>And an agent that hides its execution process so completely that users cannot inspect or correct mistakes may introduce more problems than it solves.</p><p>The measure of good agentic software shouldn’t simply be how autonomous it appears.</p><p><strong>It should be how reliably it accomplishes meaningful outcomes within the boundaries defined by the user and the business.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D8Rq1cymFC_Qb26UMw2R8g.png" /><figcaption><em>When software begins performing work on behalf of users, reliable task completion becomes a central measure of product quality.</em></figcaption></figure><h3>17. What happens to applications that don’t adapt?</h3><p>I don’t think traditional applications will suddenly become obsolete.</p><p>Software transitions are rarely that simple.</p><p>Legacy systems remain valuable because they encode years of business logic, operational knowledge, integrations, and organizational processes.</p><p>But the interaction models around those systems can change.</p><p>An application that was originally designed for human navigation may increasingly be consumed by agents.</p><p>Those agents might be embedded inside the product, provided by an external platform, or operated by another organization.</p><p>This creates an interesting competitive question.</p><p>What happens when users no longer need to visit every application’s interface to access its capabilities?</p><p>Consider a user who relies on an assistant to compare products, retrieve information, manage tasks, and coordinate services.</p><p>The assistant may interact with several applications without requiring the user to open each one individually.</p><p>In that environment, some traditional sources of product differentiation may become less important.</p><p>A polished interface remains valuable for many tasks, but it may no longer be the primary way users discover or consume every capability.</p><p>The reliability of APIs, clarity of business semantics, permission design, and quality of integrations could become increasingly important.</p><p>This doesn’t mean the API automatically becomes the entire product.</p><p>But it does mean that applications designed around reusable capabilities may be better positioned to participate in agent-driven workflows.</p><p>Applications that rely exclusively on closed, UI-specific workflows may face greater integration friction.</p><p>The long-term consequence is that software architecture becomes part of product competitiveness.</p><p>Not simply because it determines how developers build features.</p><p>But because it determines how easily new types of consumers can use those features.</p><h3>18. The application is becoming a collection of capabilities, not merely a collection of screens</h3><p>This is perhaps the most useful mental model for developers.</p><p>When designing an application, instead of starting exclusively with pages, begin by identifying the capabilities the product provides.</p><p>What business outcomes does it enable?</p><p>What operations are required to achieve those outcomes?</p><p>Which operations can execute automatically?</p><p>Which require human judgment?</p><p>What constraints and permissions govern each one?</p><p>What evidence should be returned after execution?</p><p>These questions lead to a different architectural organization.</p><p>The frontend becomes one possible expression of the product.</p><p>An agent becomes another.</p><p>Scheduled automation becomes another.</p><p>External integrations become another.</p><p>They all interact with the same governed business capabilities.</p><p>This reduces duplication and makes the application easier to evolve.</p><p>It also changes how developers should think about interfaces.</p><p>A dashboard doesn’t necessarily need to disappear.</p><p>But its purpose can change.</p><p>Instead of being the only way to operate a system, it might become a place to inspect results, monitor agents, review evidence, approve actions, and intervene when necessary.</p><p>In other words, interfaces may increasingly support supervision and control, rather than requiring humans to perform every intermediate step.</p><p>That is a much more interesting vision than replacing every interface with a chat window.</p><h3>19. The biggest engineering challenge is no longer just making software intelligent</h3><p>There’s a temptation to think that progress in AI agents depends primarily on making language models more capable.</p><p>Better reasoning.</p><p>Larger context windows.</p><p>Improved tool use.</p><p>More accurate planning.</p><p>These improvements are important.</p><p>But a more capable model doesn’t automatically produce a reliable application.</p><p>Imagine an agent that can reason perfectly about which tool it needs.</p><p>If the tool exposes an unsafe operation, the application is still vulnerable.</p><p>If the data is inconsistent, the answer can still be wrong.</p><p>If the business rules are undocumented, the agent can still make incorrect assumptions.</p><p>If the execution process isn’t durable, tasks can still fail halfway through.</p><p>If authorization isn’t enforced, the system can still access information it shouldn’t.</p><p>And if the application doesn’t preserve evidence of execution, developers may still struggle to understand what happened.</p><p>This is why agentic development requires much more than prompt engineering.</p><p>It requires software architecture.</p><p>It requires security engineering.</p><p>It requires data engineering.</p><p>It requires distributed systems principles.</p><p>And it requires a clear understanding of the business processes being automated.</p><p>The language model provides adaptability.</p><p>But reliability comes from the entire system.</p><p>An agent becomes useful when its reasoning is connected to trustworthy capabilities.</p><p>It becomes dependable when those capabilities operate within clearly defined boundaries.</p><p>And it becomes commercially valuable when it consistently achieves outcomes people care about.</p><h3>20. The future isn’t less software. It’s software with a different responsibility.</h3><p>Imagine someone ten years from now observing how we use applications today.</p><p>They watch us open multiple tabs to complete a single task.</p><p>They see us copying information between systems.</p><p>They see us downloading reports, applying filters, transferring data into spreadsheets, and repeating the same operations every week.</p><p>They might find it strange.</p><p>Not because those applications were badly engineered.</p><p>Many of them were excellent products for the technological environment in which they were created.</p><p>But because the need for humans to coordinate every individual operation may eventually feel unnecessary.</p><p>We already know that software can execute complex instructions.</p><p>The next challenge is enabling software to interpret objectives, select appropriate capabilities, execute authorized workflows, and verify the outcomes reliably.</p><p>That changes where engineering effort belongs.</p><p>We will still build applications.</p><p>We will still write APIs.</p><p>We will still design databases, develop interfaces, and maintain infrastructure.</p><p>But we’ll increasingly need to think about systems as collections of secure, composable capabilities that can be orchestrated by both humans and agents.</p><p>The architecture needs to support that possibility.</p><p>And the transition doesn’t begin with choosing an agent framework.</p><p>It begins with asking whether the application exposes its underlying capabilities in a way that makes independent, authorized execution possible.</p><p>Because a system designed only for human navigation is fundamentally different from one designed to support delegated work.</p><p>That’s why the conversation about agentic AI needs to move beyond chatbots, prompts, and model demonstrations.</p><p>We need to talk about domain boundaries, capability contracts, identity, permissions, state management, tool execution, governance, reliability, and measurable outcomes.</p><p>These are the things that will determine whether agentic applications become dependable software or remain impressive demonstrations.</p><h3>Final thought: go home and kill a button</h3><p>There’s one question I think every developer should ask about the application they’re building:</p><p><strong>What work is my user doing only because my software makes them do it?</strong></p><p>Look at the clicks.</p><p>The repeated forms.</p><p>The filters.</p><p>The exports.</p><p>The manual coordination between applications.</p><p>The steps that exist not because the user wants to perform them, but because the architecture requires them.</p><p>Then ask whether those steps could be handled by a reliable system instead.</p><p>Sometimes the answer will be an AI agent.</p><p>Sometimes it will be a deterministic workflow.</p><p>Sometimes it will simply be a better API or a cleaner application architecture.</p><p>The point isn’t to remove buttons for the sake of removing buttons.</p><p>It’s to remove unnecessary work.</p><p>Because the end of software doesn’t mean software disappears.</p><p>It means software can increasingly disappear from the <em>process of accomplishing something</em>.</p><p>The capabilities remain.</p><p>The infrastructure remains.</p><p>The business rules remain.</p><p>The engineering responsibility remains.</p><p>But the human no longer needs to understand every internal procedure required to reach an outcome.</p><p>For decades, we’ve built applications that people must learn to operate.</p><p>The next generation should be built around applications that can increasingly understand what people want to accomplish.</p><p><strong>And if we’re serious about that future, we need to start rearchitecting software today.</strong></p><h3>Further reading</h3><ul><li><a href="https://modelcontextprotocol.io/">Model Context Protocol — Official Documentation</a></li><li><a href="https://blog.modelcontextprotocol.io/posts/2026-07-28/">MCP 2026–07–28 Specification Update</a></li><li><a href="https://a2a-protocol.org/">Agent2Agent Protocol — Official Documentation</a></li><li><a href="https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html">OWASP AI Agent Security Cheat Sheet</a></li><li><a href="https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns">Microsoft Azure Architecture Center — AI Agent Design Patterns</a></li><li><a href="https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/agent-identity">Microsoft Foundry — Agent Identity</a></li><li><a href="https://www.anthropic.com/research/building-effective-agents">Anthropic — Building Effective Agents</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2dbc357a694c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do We Still Need to Build the Agent Loop?]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/do-we-still-need-to-build-the-agent-loop-dee503cfbb2e?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/dee503cfbb2e</guid>
            <category><![CDATA[microsoft-foundry]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 09:55:37 GMT</pubDate>
            <atom:updated>2026-10-30T09:55:37.501Z</atom:updated>
            <content:encoded><![CDATA[<p>Microsoft Copilot Harness changes how much agent infrastructure we need to own. Here is what that means for applications built with Microsoft Foundry.</p><p>Getting an AI agent to work in a demo is no longer the difficult part.</p><p>Give a model clear instructions, connect a few tools, and you can get something impressive running fairly quickly. The harder questions come afterwards.</p><p>What happens when a tool returns incomplete data? What happens when the investigation takes twenty steps instead of three? What happens when the agent recommends changing something the user does not have permission to change?</p><p>This is where agent development becomes an architecture problem.</p><p>In the enterprise systems I work on, connecting the model is only one part of the job. The surrounding work takes just as much attention: deciding what data the agent can access, preserving useful context, handling failures, tracing decisions, and making sure an action cannot cross a tenant boundary.</p><p>That is why the <a href="https://blogs.microsoft.com/blog/2026/10/28/introducing-the-microsoft-copilot-harness-unlocking-the-potential-of-truly-multi-model-agentic-work/">Microsoft Copilot Harness announcement</a> caught my attention. Microsoft is making a shared agent execution foundation available through Foundry, with the aim of taking more of that runtime work off developers’ hands.</p><p>For me, the interesting question is what we should still build ourselves once more of the execution machinery becomes a platform capability.</p><h3>The architecture behind a simple question</h3><p>Imagine an operations assistant connected to Microsoft Fabric.</p><p>A user asks:</p><p>“Why did our capacity consumption increase this week?”</p><p>The first version might retrieve a few metrics and ask a model to explain them. That could be useful. It could also produce a convincing explanation from the wrong comparison.</p><p>A proper investigation needs more structure.</p><p>The agent should confirm which capacity the user means, establish the time window, retrieve consumption data, compare it against a relevant baseline, and inspect the operations that contributed to the increase. It may need refresh history, workspace activity, or additional evidence before reaching a conclusion.</p><p>Even then, an increase in consumption does not automatically mean something is wrong. A scheduled data load, a new workload, or a change in business activity could explain it.</p><p>The agent needs a method for investigating the question. The application needs a reliable way to execute that method.</p><p>Someone has to decide:</p><ul><li>Which evidence remains available as the investigation grows.</li><li>How tool failures and partial results are represented.</li><li>Whether a failed operation can safely be retried.</li><li>When the agent has enough evidence to stop.</li><li>Which actions require approval.</li><li>How the result can be checked afterwards.</li></ul><p>That work is the reason a working agent demo and a dependable business application can feel like two different projects.</p><h3>What Copilot Harness changes</h3><p>Microsoft <a href="https://devblogs.microsoft.com/foundry/microsoft-copilot-harness-in-foundry/">introduced Copilot Harness in Foundry Agent Service in public preview on October 28, 2026</a>. Microsoft operates the execution loop and sandbox; developers provide the instructions, skills, tools, and supported model configuration.</p><p>The architectural change is a shift in responsibility.</p><p>In a custom implementation, your application may coordinate model calls, dispatch tools, assemble working context, manage intermediate files, and decide how the task proceeds. You may use a framework to help, but your team still maintains the execution logic.</p><p>With a managed harness, you can hand more of that coordination to the platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LiLgWxZj69fkVh_aV0WZKg.png" /><figcaption>Custom agent orchestration versus Microsoft Copilot Harness. Show which responsibilities move to the managed runtime and which remain with the application</figcaption></figure><p>This is useful because execution infrastructure has a real maintenance cost.</p><p>A loop that works for a straightforward task can become difficult to operate once it needs to handle interruptions, large tool responses, multiple steps, and changing model behaviour. Every additional capability creates more interactions to test.</p><p>Moving that work into a managed runtime can reduce what your team has to maintain. Whether it improves the application still depends on how well it handles your actual workloads.</p><p>The ownership boundary matters here: Microsoft can operate the runtime, while your application remains responsible for what that runtime is allowed to do.</p><h3>Foundry is the platform. The harness is an execution choice.</h3><p>The naming deserves some attention.</p><p><a href="https://learn.microsoft.com/en-us/azure/foundry/agents/overview">Foundry Agent Service</a> supports both declarative prompt agents and code-based hosted agents. That gives developers different levels of control over how their agents run.</p><p>Copilot Harness fits within that broader platform.</p><p>I would think about the choice in terms of the work:</p><p>A contained task may need instructions and a few supported tools. A longer investigation may benefit from a managed runtime that coordinates several steps. A specialised application may need its own execution logic.</p><p>There is also a related SDK announcement. GitHub is <a href="https://github.blog/changelog/2026-10-28-github-copilot-sdk-is-becoming-microsoft-copilot-sdk/">transitioning GitHub Copilot SDK to Microsoft Copilot SDK</a>, describing it as the programmable interface to the shared harness. That direction is related to Foundry’s managed offering, but the integration and hosting choices still need to be evaluated separately.</p><p>For an architecture decision, I would start with the control the application needs and then choose the appropriate execution model.</p><h3>Instructions, skills, and tools do different jobs</h3><p>One useful way to design an agent is to separate its objective, its method, and its capabilities.</p><p>The instructions establish the objective:</p><p>“Investigate the increase in Fabric capacity consumption and produce a report supported by evidence.”</p><p>A skill describes the method:</p><p>“Confirm the scope, compare consumption against a baseline, inspect contributing operations, and explain any gaps in the evidence.”</p><p>Tools provide the capabilities:</p><p>“Retrieve capacity consumption, refresh history, and workspace activity.”</p><p>These distinctions make the system easier to reason about.</p><p>A tool can return technically correct data while the agent follows a poor investigation method. A well-written procedure can still fail if the tools expose incomplete evidence. Clear instructions cannot compensate for an incorrectly scoped identity.</p><p>I would design and evaluate those parts separately, then test how they work together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TkRK0oYb2W6W6Nd4ZjogRQ.png" /><figcaption>Conceptual execution loop showing the user’s goal, working context, model decisions, tool execution, and returned evidence.</figcaption></figure><p>There is another distinction I would keep explicit: a written procedure guides the agent, while application code enforces permissions.</p><p>A skill can tell an agent to remain within the authorised tenant. The service receiving the tool call must enforce that tenant boundary independently.</p><p>The same applies to approvals, spending limits, and write access. Instructions help describe the intended behaviour. Enforcement belongs in the systems that control the action.</p><h3>How I would design a Fabric investigation agent</h3><p>Consider this request:</p><p>“Our Fabric capacity looks expensive this week. Find out what changed and tell us what we should fix.”</p><p>I would build the investigation around a read-only path.</p><p>The application authenticates the user, resolves the tenant, and determines which workspaces and capacities that user can inspect. Those decisions establish the scope before the agent begins retrieving business data.</p><p>The agent receives the task and calls a small set of domain tools through an application-controlled gateway.</p><p>For example:</p><ul><li>get_capacity_consumption</li><li>get_refresh_history</li><li>get_workspace_activity</li><li>get_capacity_configuration</li></ul><p>Each operation should have a clear purpose, typed arguments, predictable outputs, and explicit failure states.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zSVBHSLms8c09nXoZ2AzSQ.png" /><figcaption>Fabric investigation architecture. Show the authenticated application, Foundry agent, scoped tool gateway, Fabric telemetry, and separate approval workflow</figcaption></figure><p>The gateway validates the request against the authenticated scope. It should reject an unauthorised capacity identifier even if the model supplies one confidently.</p><p>The tool responses should also carry enough context to support a meaningful investigation: the period covered, measurement units, aggregation level, collection time, and any missing intervals.</p><p>That context affects the conclusion.</p><p>For example, a peak utilisation value and an average utilisation value answer different questions. A daily average can hide short periods of severe pressure. A missing telemetry interval can make a quiet period look like low usage.</p><p>If the agent does not understand those differences, it can produce a polished report that leads someone towards the wrong decision.</p><p>I would therefore expect the final report to explain:</p><ul><li>What changed and when.</li><li>Which workloads contributed.</li><li>Which measurements support the finding.</li><li>What remains uncertain.</li><li>Which action is worth considering.</li></ul><p>A useful investigation should make its reasoning checkable through evidence.</p><h3>A recommendation should not quietly become an action</h3><p>Suppose the agent concludes that a refresh schedule is contributing to repeated capacity pressure.</p><p>Recommending a schedule change is one decision. Applying that change introduces additional requirements.</p><p>The application needs to establish whether the user can authorise it, show the proposed modification, capture approval, and validate the request again before execution.</p><p>The approval should refer to a specific operation with specific arguments. A general “yes, go ahead” becomes ambiguous if the agent has proposed several changes or the underlying configuration has changed.</p><p>I would also record the result and design the operation so a retry cannot accidentally apply the same change twice.</p><p>That last point matters because failures are not always clear.</p><p>A request can time out after the external service has already completed the action. Retrying blindly may create a second report, submit another job, or repeat a business transaction.</p><p>The runtime can help coordinate recovery. The application must understand what repeating an operation means.</p><h3>What I would still own</h3><p>A managed harness would change where I spend engineering time. These responsibilities would remain central to the application.</p><h3>Identity and tenant isolation</h3><p>Every tool call needs a clear identity and an enforceable scope.</p><p>The application should know whether it is using delegated user permissions, an application identity, or another supported authentication pattern. That choice affects what data the tool can retrieve and what actions it can perform.</p><p>In a multi-tenant product, tenant isolation needs to hold even when the agent supplies an incorrect identifier or retrieves misleading content.</p><h3>Tool contracts</h3><p>Tool design shapes agent behaviour.</p><p>A broad administrative endpoint gives the agent a large space in which to make mistakes. Narrow operations make the available actions easier to understand, validate, and audit.</p><p>The contract should distinguish between an empty result, missing data, a permission denial, and a temporary service failure. Those conditions should lead to different next steps.</p><h3>Evidence quality</h3><p>Retrieving data is only useful if the agent can interpret it correctly.</p><p>I would preserve units, timestamps, filters, and data-quality limitations in tool responses. Where calculations affect a recommendation, I would make the inputs and method inspectable.</p><p>An explanation should become less confident when the evidence is incomplete.</p><h3>Observability</h3><p>A successful HTTP response tells me that a request completed. It tells me very little about whether the investigation was useful.</p><p>I want traces that help answer practical questions: which tools ran, what failed, which configuration was active, how long the task took, and what evidence supported the result.</p><p>Logging also needs appropriate access controls and redaction. A trace should help diagnose the application without becoming an unnecessary copy of sensitive business data.</p><h3>Evaluation</h3><p>I would test the agent against known operational scenarios.</p><p>That includes ordinary cases, permission denials, partial telemetry, conflicting measurements, rate limits, and workloads where the correct response is to request more evidence.</p><p>A system that can acknowledge uncertainty is more useful than one that always finds something to recommend.</p><h3>When I would keep a custom execution loop</h3><p>I would keep custom orchestration where its behaviour is part of the application’s requirements.</p><p>For example, a workflow may need a fixed sequence of validated stages. A business process may require a deterministic policy check before every write. A specialised workload may depend on custom middleware, scheduling, or state transitions.</p><p><a href="https://learn.microsoft.com/azure/ai-foundry/agents/concepts/hosted-agents">Hosted agents in Foundry</a> provide a path for running your own agent code and framework while using managed hosting.</p><p>The important question is whether the control is necessary.</p><p>Owning a custom loop creates a continuing responsibility: maintaining dependencies, understanding failure behaviour, testing model changes, and operating the service. That investment makes sense when it supports a concrete requirement.</p><p>For other workflows, a managed harness may free the team to spend more time improving the tools, evidence, and product experience.</p><h3>How I would evaluate a migration</h3><p>I would choose a representative workflow and compare the existing implementation with the managed option.</p><p>For the Fabric example, I would use the same investigation requests, data snapshots, permissions, and expected findings. I would include difficult cases from the beginning.</p><p>Then I would measure:</p><p><strong>Accuracy.</strong> Does the agent identify the actual contributing workloads? Does it support its conclusions with the right measurements?</p><p><strong>Recovery.</strong> What happens when a tool times out, returns partial data, or rejects a request?</p><p><strong>Control.</strong> Are tenant boundaries and approval requirements enforced throughout the task?</p><p><strong>Cost.</strong> What is the total cost of a completed investigation, including unsuccessful attempts and retries?</p><p><strong>Latency.</strong> How long does the user wait for a useful answer?</p><p><strong>Operability.</strong> Can the team reproduce a failure, inspect the evidence, and deploy a correction with confidence?</p><p>I would pay particular attention to cost per successful task. A lower-cost model call is less useful if the agent needs more calls, repeats work, or produces reports that require substantial manual correction.</p><p>I would also version the instructions, skills, tool schemas, and configuration used in each test. Otherwise, it becomes difficult to explain why one run performed differently from another.</p><h3>What the preview means for adoption</h3><p>The <a href="https://devblogs.microsoft.com/foundry/microsoft-copilot-harness-in-foundry/">launch announcement</a> says the harness is selected when creating an agent; switching it afterwards is not yet supported. It also lists runtime billing from December 1, 2026, while model and connected-service charges remain applicable beforehand.</p><p>I would treat those details as part of the implementation decision.</p><p>Before adopting it for a business workflow, I would check the current documentation against the models, authentication patterns, tools, and deployment requirements that workflow actually needs.</p><p>For an existing application, I would start with one bounded investigation, establish an evaluation baseline, and expand from the results.</p><h3>Where I think this is heading</h3><p>We are moving towards a point where more of the machinery around AI models becomes standard infrastructure.</p><p>That is a familiar pattern in software. Teams build the supporting systems they need, and platforms eventually absorb the parts that many applications share.</p><p>Agent execution appears to be following that path.</p><p>As more of the runtime becomes managed, engineering effort can move towards the things that determine whether an agent is useful: the quality of its evidence, the design of its tools, the permissions around its actions, and the experience of the person relying on it.</p><p>That is what makes Copilot Harness interesting to me.</p><p>I would still expect to do serious architecture work. I would simply ask a different question at the start:</p><p>Which parts of this system actually require us to own the execution loop?</p><p>For some applications, the answer will remain substantial. For others, maintaining another loop around a model may become a smaller part of the job.</p><p>The value will come from what we build with the time that gives us back.</p><p><em>Product information reflects the announcements available on October 30, 2026. The Fabric workflow and image placeholders describe an illustrative architecture, rather than an official Microsoft reference implementation.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dee503cfbb2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why your Fabric data agent ignores your Foundry instructions]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/why-your-fabric-data-agent-ignores-your-foundry-instructions-0764c67ffef2?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/0764c67ffef2</guid>
            <category><![CDATA[microsoft-foundry]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 09:56:13 GMT</pubDate>
            <atom:updated>2026-10-14T09:56:13.451Z</atom:updated>
            <content:encoded><![CDATA[<p>Let’s start with a simple question: What was our revenue last quarter?</p><p>You’ve built a Foundry agent. It’s connected to a <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/fabric">Fabric data agent</a> sitting on your sales lakehouse. In the Foundry instructions you wrote one clear line:</p><p>The instruction says, “Revenue does not include returned orders.”</p><p>But you ask how much we made last quarter, and the number you get still includes returns.</p><p>Nothing fails. No error, no warning. The instruction was right there, but it was ignored.</p><p>Let’s trace what actually happened, from the question all the way down to the SQL query, then back up to the answer you get.</p><h3>Going down: it’s three models, not one</h3><p>It might look like you’re talking to one agent, but there are actually three involved.</p><p><strong>Step 1: The Foundry agent.</strong> It reads your question, decides to call the Fabric tool, and generates a new message to send to Fabric. So what Fabric receives isn’t necessarily what you originally asked. It’s what Foundry decides to send.</p><p><strong>Step 2: The Fabric data agent.</strong> This is a separate orchestrator with its own instructions. It takes that message from Foundry and decides which data source to use.</p><p><strong>Step 3: The query generator.</strong> This is where the actual query gets written. Depending on the data source, it could be <a href="https://learn.microsoft.com/en-us/fabric/data-science/data-agent-sql-sources">NL2SQL</a> for a lakehouse or warehouse, DAX for a Power BI semantic model, or KQL for an Eventhouse.</p><p>Each step only works with what the previous step passes to it.</p><p>Your instruction is in Step 1, but the SQL gets written in Step 3. By the time the query is generated, that original instruction might be missing entirely.</p><p>And there’s another detail worth knowing. Microsoft’s own <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/fabric">documentation</a> says that the model you select in Foundry doesn’t change which model Fabric uses for NL2SQL.</p><p>So switching from GPT to Claude in Foundry won’t necessarily fix a bad query. Foundry isn’t the one generating the SQL in the first place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EEmNbnfh1B5IjYe5q_OZqg.png" /><figcaption>A question gets rewritten going down and rephrased coming back up, and the Foundry instruction never reaches the SQL.</figcaption></figure><h3>The question changes on the way down</h3><p>This is the part that surprised me the most.</p><p>Foundry doesn’t simply pass your user’s original message to Fabric. When it calls a tool, the model generates a new set of arguments for that tool.</p><p>So a question like “What was revenue last quarter?” could reach Fabric as “Get total sales for Q3 2026.”</p><p>Think about what just happened. “Revenue” became “sales”, and “last quarter” became Q3 2026.</p><p>Those are two decisions your user never made. Foundry made them before Fabric even got the question.</p><h3>The answer changes on the way up</h3><p>Fabric sends back the result, but we’re not done yet. The Foundry model gets another go at it.</p><p>It can round numbers, summarise a table into a sentence, or change how the result is presented. There have even been <a href="https://github.com/orgs/azure-ai-foundry/discussions/192">reports of Foundry agents rephrasing the data agent’s answer or dropping rows at the end</a>.</p><p>So even if Step 3 gets the query right and returns the correct data, Step 1 can still change what your user actually sees.</p><h3>Where each rule actually belongs</h3><p>Once you understand the three steps, the fix is pretty straightforward. Put each instruction where it’s actually needed.</p><p><strong>Step 1: The Foundry agent.</strong> Keep it focused on routing and handing off the request. Business definitions don’t belong here.</p><pre>For questions about sales, revenue, customers or orders, use the Fabric tool.<br>Send the user&#39;s question to the Fabric tool exactly as they wrote it.<br>Do not rewrite it. Do not add dates, filters or definitions.<br>Report every number exactly as Fabric returns it. Don&#39;t round or recalculate.<br>If Fabric asks a clarifying question, ask the user. Don&#39;t answer it yourself.</pre><p>“Exactly as they wrote it” is the important bit here. It stops Foundry from interpreting the question before Fabric even gets to see it.</p><p><strong>Step 2: The Fabric data agent.</strong> This is where you define which data source handles what and how the answers should be returned. Put those rules in the <a href="https://learn.microsoft.com/en-us/fabric/data-science/data-agent-configuration-best-practices">data agent instructions</a>.</p><pre>Use SalesLakehouse for revenue, orders and customers.<br>Always say which date range you used.</pre><p><strong>Step 3: The lakehouse or warehouse.</strong> This is where you actually define what “revenue” means. Put the rule in the data source instructions, then back it up with an <a href="https://learn.microsoft.com/fabric/data-science/data-agent-example-queries">example query</a> that shows exactly how it should work.</p><pre>Revenue = SUM(SalesDetail.LineTotal) where SalesHeader.Status &lt;&gt; &#39;Returned&#39;.<br>&quot;Last quarter&quot; = the last complete calendar quarter, using SalesHeader.OrderDate.</pre><pre>-- Question: What was revenue last quarter?<br>SELECT SUM(d.LineTotal) AS Revenue<br>FROM dbo.SalesHeader h<br>JOIN dbo.SalesDetail d ON d.SalesOrderID = h.SalesOrderID<br>WHERE h.Status &lt;&gt; &#39;Returned&#39;<br>  AND h.OrderDate &gt;= DATEADD(QUARTER, DATEDIFF(QUARTER, 0, GETDATE()) - 1, 0)<br>  AND h.OrderDate &lt;  DATEADD(QUARTER, DATEDIFF(QUARTER, 0, GETDATE()), 0);</pre><p>Instructions alone aren’t always enough. An example query gives the generator a pattern to follow when a similar question comes up. Use both.</p><p>There’s one catch, though. Fabric validates every example query against your schema. If it fails, Fabric simply doesn’t send it to the agent.</p><p>Rename a table, and your examples could quietly stop working. You won’t necessarily get a warning. The run steps view shows which examples were actually used for a question, so check it whenever you change the schema.</p><p><strong>Step 3: A Power BI semantic model.</strong> This is where things get a bit different.</p><p>Semantic models <a href="https://learn.microsoft.com/en-us/fabric/data-science/data-agent-add-datasources#semantic-model-supported-configurations">don’t support data source instructions or example queries</a> in the data agent.</p><p>And as <a href="https://www.jamesserra.com/archive/2026/10/prep-data-for-ai-vs-fabric-data-agent-instructions-what-goes-where/">James Serra pointed out</a>, even the data agent’s own instructions don’t reach the DAX generator.</p><p>So where do you put the rule? In <a href="https://learn.microsoft.com/en-us/power-bi/create-reports/copilot-prepare-data-ai">Prep data for AI</a>, directly on the semantic model.</p><pre>For revenue, use the [Net Sales Amount] measure. It excludes returns.</pre><p>Nice side effect: Power BI Copilot reads the same definition. Write it once.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-LShKLtrfLsW9vnpVbhSPA.png" /><figcaption>Where each rule belongs, from Foundry routing down to lakehouse rules and Prep data for AI.</figcaption></figure><h3>Three things that can trip you up later</h3><p><strong>Ambiguous questions.</strong> Standard NL2SQL tends to make an assumption and go with it. The newer <a href="https://learn.microsoft.com/en-us/fabric/data-science/data-agent-sql-sources">Advanced NL2SQL</a>, available on the preview runtime, can pause and ask the user to clarify first. If you enable it, make sure Step 1 passes that question back to the user instead of trying to answer it on its own.</p><p><strong>Slow queries.</strong> Heavy queries can hit a <a href="https://techcommunity.microsoft.com/discussions/azure-ai-foundry-discussions/agent-with-fabric-data-agent-tool-times-out-at-100s-even-in-background-mode/4552775/replies/4553399">100-second tool-call limit</a>. For longer-running queries, enable background mode. One thing to note: of the Fabric IQ item types, <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/fabric-iq">only the data agent endpoint supports it</a>.</p><p><strong>“It works for me.”</strong> Every call runs as the signed-in user, and <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/tools/fabric">service principals aren’t supported</a> for the Fabric data agent tool. So if everything works for you but fails for other users, check their permissions before changing your configuration.</p><h3>How to know it’s fixed</h3><p>Don’t just look at the answer. Look at the query itself.</p><p>Open the run and find the SQL. Is Status &lt;&gt; &#39;Returned&#39; in there? If not, the rule still isn&#39;t reaching the step where the query gets generated.</p><p>Next, check what Foundry actually sent to Fabric. Does it match what the user asked? If not, Step 1 is still rewriting the question.</p><p>That’s it. Two quick checks, and you can catch both problems in about a minute.</p><h3>Before you ship, check these</h3><p>If there’s one part of this blog worth saving, it’s this checklist:</p><ul><li>Foundry knows when to call Fabric and passes the user’s question word for word. No business definitions here.</li><li>Business rules live in the data source instructions for a lakehouse or warehouse, or in Prep data for AI for a semantic model.</li><li>Every important rule has an example query to show how it should work.</li><li>You’ve checked the run steps after your last schema change.</li><li>You’ve reviewed the actual SQL for your top 10 questions, not just the answers.</li></ul><p>Put the rule where the query gets written. Everything else is routing.</p><p>Have fun building cool data agents with Foundry :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0764c67ffef2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsoft Foundry Is Becoming the Operating System for AI Agents]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/microsoft-foundry-is-becoming-the-operating-system-for-ai-agents-ffb9d6b16e0c?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffb9d6b16e0c</guid>
            <category><![CDATA[microsoft-foundry]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 05:47:15 GMT</pubDate>
            <atom:updated>2026-09-09T05:47:15.413Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The next round of enterprise AI won’t be won by whoever has the best model. It’ll be won by whoever owns the layer that makes thousands of agents actually work.</em></p><p>I spent some time building an enterprise analytics agent. The model was the easy part.</p><p>What took most of the work was everything around it. Identity. Permissions. Domain-specific tools. Evaluation. Observability. All the infrastructure that determines what an agent can access, what it can do, and whether you can trust what happened after it acted.</p><p>The industry is still arguing about the wrong thing. Which model is best. GPT or Claude. Llama or DeepSeek. Big reasoning model or small cheap one.</p><p>Fine question. Not the important one.</p><p>AI apps stopped being things that answer you. They became things that do things for you. And once an agent has to search your knowledge base, hit a database, call an API, run code, prove who it is, follow policy, and leave a trail you can audit, the model isn’t the app anymore. It’s a part in the app.</p><p>That gap is a new layer. <a href="https://learn.microsoft.com/en-us/azure/foundry/what-is-foundry">Microsoft Foundry</a> is building it.</p><p>Foundry puts models, agent building, tools, knowledge, evaluation, monitoring and governance in one place. Agent Service runs and scales the agents. The Control Plane sits above the whole fleet and gives you visibility and control.</p><p>So say it plainly. Foundry is starting to look less like an AI studio and more like an operating system for enterprise agents.</p><p>Not literally. But look at the architecture and the comparison stops being a stretch.</p><h3>The model used to be the center</h3><p>The first wave of AI apps was simple. A user typed a prompt. The app called a model. The model sent back text.</p><p>You spent your time on prompts, context windows, which model to pick. The model sat in the middle of everything.</p><p>Now try a real request:</p><p><em>“Find the customers whose renewal odds dropped this quarter, work outwhy, find the account owners, and draft an outreach plan.”</em></p><p>You can’t do that by generating text. The agent has to query a semantic model, pull customer records, search internal docs, run the numbers, hit a CRM, reason across all of it, maybe ask a human before it touches anything external, and record what it did.</p><p>The model still matters. It just isn’t the system. The agent is. And agents break in ways a single model call never did.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1zHcrMep59INONNY25QBxw.png" /><figcaption>A three-stage diagram showing AI evolving from direct model calls to agents with tools and knowledge, then to full agent systems with runtime, data, identity, memory, evaluation, observability, and governance.</figcaption></figure><h3>The real work is the layer around the model</h3><p>Here’s why the Foundry bet is interesting.</p><p>No enterprise wants to marry one model forever. Models change. Prices change. Latency changes. The model that’s right today looks dated in eighteen months when a better reasoning model shows up.</p><p>So the shape moves from App → Model to App → Agent Platform → Model.</p><p>That gap is bigger than it reads. If the model changes but the agent’s identity, tools, policies, telemetry and deployment stay put, you don’t rebuild anything. You swap a part.</p><p>The platform becomes the thing you build on. And the thing you build on is the thing that lasts.</p><h3>Foundry is becoming the runtime</h3><p>The runtime is the strongest part of the comparison.</p><p>Agent Service is a managed place to build, deploy and scale agents. It handles the conversation, the tool calls, the lifecycle. And Microsoft lets you decide how much of it you want to own.</p><p>At one end, <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/quickstarts/prompt-agent?tabs=python">prompt agents.</a> You give it instructions, a model, tools. Foundry runs it.</p><p>At the other end, <a href="https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/hosted-agents">hosted agents</a>. You bring your own code and framework, package it, and Foundry gives it a managed endpoint, scaling, identity and observability. The documented list of supported frameworks already includes Microsoft Agent Framework, LangGraph, the OpenAI Agents SDK, the Anthropic Agent SDK and the GitHub Copilot SDK.</p><p>That’s the tell. Foundry isn’t saying build agents the Microsoft way. It’s saying bring the agent you have, we’ll wrap the enterprise plumbing around it. That’s how an operating system behaves.</p><h3>The tool layer matters more than the model layer</h3><p>A model can reason. A tool lets the agent do something. That difference is the whole agentic era.</p><p>I saw this directly with an analytics agent. The model could understand the business question, but understanding it wasn’t enough. It needed tools that could actually perform the calculations and operate against real data.</p><p>The thinking came from the model. The doing came from the tools.</p><p>So the tool layer is where the leverage sits. Foundry ships web search, file search and code interpreter, and lets agents use custom functions, OpenAPI tools and MCP servers. Toolboxes let you curate a set once and reuse it across agents, with the auth and versioning handled centrally.</p><p>That changes the math. Without a shared layer, every agent wires up its own connection to the CRM. Five agents, five copies of the same integration, five things to break at 2am. With a governed tool layer, the agents share one connection and the tool becomes infrastructure.</p><p>Small shift. It changes everything downstream.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gl2IUTl7-Y8QDVbpNMA4RQ.png" /><figcaption>A layered diagram showing five business agents connected to a shared Foundry Tool Layer that provides common capabilities like MCP, search, code, and APIs, which then connects to enterprise systems such as CRM, ERP, SQL, SharePoint, data warehouses, and SaaS apps.</figcaption></figure><h3>MCP makes the problem bigger</h3><p>MCP gives agents a standard way to plug into tools and outside resources. Good. At enterprise scale it also creates a new problem.</p><p>Picture a company with hundreds of agents and hundreds of MCP tools wired into customer data, source code, finance systems, email, internal docs, production infrastructure. The question stops being “can the model answer.” It becomes “what is this agent allowed to do.”</p><p>That’s a platform problem, not a model problem. Foundry handles the managed connections and the authentication, and Microsoft is building governance around MCP and agent tool access.</p><p>An operating system doesn’t just hand out resources. It controls who reaches them. The second software can act in the world on its own, you need the same thing.</p><h3>Agents need identities</h3><p>This might be the sharpest break between old software and autonomous agents.</p><p>Old enterprise software ran under one application identity. That doesn’t survive agents. If you have a hundred finance agents, three hundred sales agents, fifty engineering agents, you can’t treat them as one blob called “AI Agent.” You need to know which agent acted, what it could touch, who authorized it, and whether you can audit it after the fact.</p><p>I hit this head on while building enterprise agents. Knowing who is asking the question isn’t enough. The system also has to preserve what that person is actually allowed to access as the agent works.</p><p>A user should only receive information they are authorized to see. That becomes much harder to guarantee when agents operate behind broad, shared identities.</p><p>Foundry ties into Microsoft Entra and RBAC, and hosted agents can carry their own identity. So the old model of humans plus applications becomes humans plus applications plus agents. Agents need identities because agents can act.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_NWSb0hazTY6cFJ0ZfKRig.png" /><figcaption>A diagram showing an employee delegating work to Finance, Sales, and Engineering agents, each with its own identity and distinct permissions enforced through Microsoft Entra ID, RBAC, least privilege, and policy before accessing enterprise resources.</figcaption></figure><h3>The hard part is knowing whether it worked</h3><p>Building an agent isn’t the hard part anymore. Trusting it is.</p><p>A normal API you test. Input, expected output, done. An agent runs a chain. Request, reason, search, tool call, result, reason, another tool call, action, response. The final answer can look completely reasonable while the process underneath was wrong.</p><p>Maybe it called the wrong tool. Used stale data. Misread the intent. Pulled the wrong document. Made a call it didn’t need. Ran past its permissions. Failed halfway and covered it with a confident summary.</p><p>You’d never catch that from the output. So observability stops being optional. Foundry does tracing, evaluation and monitoring, plugs into Application Insights, and adds agent-specific metrics like tool-call accuracy and task completion next to groundedness and relevance.</p><p>It answers the one thing normal app monitoring can’t. What did the agent actually do.</p><h3>Evaluation is the new unit test</h3><p>This is one of the real changes in how you work.</p><p>Old software gives you unit tests, integration tests, production monitoring. Agent work gives you evaluation, tracing, continuous evaluation, monitoring, then round again. Build, test, deploy, trace, evaluate, improve, deploy.</p><p>Foundry runs evals in development and in production, across quality, safety, groundedness, relevance, tool-call accuracy and task completion, on a schedule if you want.</p><p>The loop matters because an agent isn’t static. Change the model, the behavior moves. Change the prompt, it moves. Change a tool description, or the data it retrieves, or the model version, it moves again.</p><p>I’ve seen this repeatedly while building agents. Every meaningful change can move the system’s behavior somewhere you didn’t expect, which means you have to evaluate it again.</p><p>You don’t ship an agent and walk away. You keep measuring it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GtNT9WbALwNPyIua5B_ufQ.png" /><figcaption>A circular lifecycle diagram showing a Production Agent surrounded by models, tools, data, identity, and policies, progressing through Build, Test, Deploy, Trace, Evaluate, and Optimize in a continuous measurement loop.</figcaption></figure><h3>Then comes scale</h3><p>One agent is easy. Ten is manageable. A thousand is infrastructure.</p><p>Give every department the ability to spin up agents and it happens fast. Finance builds one. Sales builds ten. Engineering builds fifty. Support builds a hundred. Now you have a fleet, and the questions change. Not “does this agent work” but “what agents do we even have, who owns them, which models are they on, what can they reach, what are they costing, which ones are failing, which ones are breaking policy.”</p><p>That’s the exact job the Foundry Control Plane goes after. One place to see, govern and control agents, models and tools across the company, from build to production.</p><p>I’ve felt the front edge of this myself. In building enterprise governance and multi-agent systems, I’ve seen how quickly the problem changes once AI moves beyond a single application. At tenant scale, governance is no longer just about defining policies or reviewing systems before deployment. It has to become part of the platform itself, continuously enforcing security, access, observability, and operational controls while workloads are running.</p><p>The same pattern appears even at a much smaller scale. Once you have several agents coordinating, sharing tools, and acting across different workflows, visibility and control become essential. A handful of agents is already enough to make the need for a control plane obvious. At enterprise scale, that need becomes infrastructure.</p><p>This is the clearest evidence for the operating system read. The job shifts from managing an application to managing a population of them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KZ49SDCokbgE54YLbOiH1A.png" /><figcaption>A left-to-right evolution diagram showing a single agent growing into multiple specialized agents and then an enterprise agent fleet managed by a Foundry Control Plane for identity, policy, observability, evaluation, cost, compliance, and deployment.</figcaption></figure><h3>The platform becomes the abstraction layer</h3><p>Stack it all up and the picture looks nothing like the AI apps of a few years ago.</p><p>Cloud at the bottom. The AI platform above it, managing models, hosting agents, exposing tools, connecting knowledge, doing identity, observability, evaluation, governance. Business agents on top.</p><p>The model is still critical. It just isn’t the whole story now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wQLP1cc6MAz6vyHb4xQ71w.png" /><figcaption>A layered architecture diagram showing cloud infrastructure supporting Microsoft Foundry, its control plane, enterprise agents, and business applications, with a BUILD → RUN → OBSERVE → EVALUATE → GOVERN lifecycle across the platform.</figcaption></figure><h3>Which is why the model choice matters less</h3><p>There’s a paradox here. The better models get, the less sense it makes to build your whole stack around one of them.</p><p>The value keeps sliding off the model. A sales agent reasons with one model. A classification task uses another. A quick call uses something small. A heavy financial analysis reaches for a stronger reasoning model. A coding task uses one tuned for code. The platform is where those choices live.</p><p>Foundry supports models from its catalog and lets you bring your own agent and framework. Which points at one line worth writing down. The durable asset is the agent system, not the model.</p><p>Your tools. Your knowledge. Your identity model. Your eval datasets. Your policies. Your telemetry. Those are hard to rebuild. A model you can swap.</p><h3>Foundry isn’t Windows for AI</h3><p>One caveat before anyone runs too far with this.</p><p>Foundry isn’t literally the operating system for AI. The world is too spread out for that. Companies run agents outside Foundry. They use other clouds. They run LangGraph or their own framework on their own boxes and never touch Microsoft’s control plane. Nobody owns this the way one company once owned the desktop, and maybe nobody will.</p><p>But the analogy holds where it counts. The value is moving off the model and onto the layer around it. Identity. Tools. Evaluation. Governance. The stuff that takes most of the engineering effort to get right.</p><p>You can swap a model in an afternoon. You can’t swap a year of agent infrastructure. That’s the part worth building. And that’s the layer Foundry is trying to own.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffb9d6b16e0c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsoft Is Turning Excel Into an AI Agent — Here’s What It Can Actually Do]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/microsoft-is-turning-excel-into-an-ai-agent-heres-what-it-can-actually-do-b90741f58f4d?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/b90741f58f4d</guid>
            <category><![CDATA[excel]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 05:23:29 GMT</pubDate>
            <atom:updated>2026-09-09T05:23:29.109Z</atom:updated>
            <content:encoded><![CDATA[<p>Excel has always been a powerful tool, but it has also required you to know exactly what you are doing.</p><p>If I have a workbook containing thousands of sales records and I want to know which regions are becoming less profitable, I have to figure out how to get that answer myself. I might calculate gross margin with a formula, create a PivotTable to group the numbers by region and month, and then create a chart to understand the trend.</p><p>None of these steps is particularly difficult on its own. The problem is that I have to know which steps are necessary and perform them in the right order.</p><p>This is the part of Excel that Microsoft is starting to change with <a href="https://support.microsoft.com/en-us/excel/copilot/get-started-with-copilot-in-excel">Copilot.</a></p><p>Instead of asking me to specify every operation I want Excel to perform, Copilot can take a higher-level request, work out the steps required, and make those changes directly inside the workbook.</p><p>For example, I could give it a request like this:</p><pre>Analyse this sales workbook and identify the regions where gross<br>margin has declined for at least three consecutive months. Create<br>a summary by region and month and add a chart showing the trend.</pre><p>That request does not tell Excel to create a particular formula or PivotTable. It describes the result I want.</p><p>Copilot has to work out how to get there.</p><p>That is the interesting change happening inside Excel.</p><h3>Excel has always required you to know the next operation</h3><p>The traditional spreadsheet workflow is built around individual operations.</p><p>You have your data, and then you decide what needs to happen to it.</p><p>Maybe you need a formula. So you write one.</p><p>Maybe you need to summarize the data. So you create a PivotTable.</p><p>Maybe you need to compare two categories. So you filter the data.</p><p>Maybe you want to present the result. So you create a chart.</p><p>The user is effectively the system that connects all of these operations together.</p><p>That works extremely well when you already understand Excel. But it creates a barrier for people who understand the question they want to answer without necessarily knowing the best Excel feature to use.</p><p>This is where an agent changes the interaction.</p><p>I can describe the outcome and let the software determine the sequence of operations needed to produce it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g97VNN1kcskdQ7iwFjFq7Q.png" /><figcaption>Traditional Excel workflow vs. Copilot workflow, comparing manual Excel tasks with natural-language instructions to Copilot.</figcaption></figure><p>The difference is subtle if you look at one operation at a time. It becomes much more significant when a request involves several operations.</p><p>A request such as “calculate gross margin” is simple.</p><p>A request such as “analyse the last six months, identify regions with declining margins, compare them with the previous period, and create a report” is a workflow.</p><p>That is the type of task Copilot is increasingly designed to handle.</p><h3>What actually happens when Copilot edits a workbook?</h3><p>Microsoft’s current Copilot experience in Excel includes Edit, Plan, and Chat modes.</p><p><strong>Chat</strong> is useful when I want Copilot to analyse or explain something without changing the workbook. Plan is useful when I want to work out an approach before making changes. Edit is the mode that makes the experience feel much more agent-like because Copilot can actually modify the workbook.</p><p>The important thing here is that Copilot is not simply generating an answer in the side panel.</p><p>When I ask it to perform a task, it can inspect the workbook, determine the operations needed, make those changes, and evaluate the result.</p><p>So take the sales example again.</p><p>If I ask Copilot to identify regions with declining gross margins, there are several things it needs to understand before it can produce a useful result. It needs to identify the relevant data, work out how gross margin should be calculated, organize the information by the dimensions I requested, and then present the result in a way that makes the trend understandable.</p><p>The agent therefore has to move between understanding my request and working with the actual workbook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVd4eiJ_owfr4YOpExScxw.png" /><figcaption>A flow diagram showing Copilot turning a natural-language request into Excel formulas, tables, PivotTables, charts, reviewed results, and completed analysis returned to the workbook.</figcaption></figure><p>This is also why calling it simply an “AI assistant” misses part of what is happening.</p><p>An assistant might tell me how to create a PivotTable.</p><p>An agent can potentially create the PivotTable for me as part of a larger task.</p><p>That difference matters.</p><h3>The workbook is still the source of truth</h3><p>Even though Copilot is becoming more capable, Excel itself has not disappeared underneath the AI.</p><p>This is probably one of the most important things to understand about Microsoft’s approach.</p><p>When Copilot creates a formula, the formula remains an Excel formula. When it creates a PivotTable, it is still an Excel PivotTable. When it creates a chart, the chart remains part of the workbook and can be edited normally.</p><p>That means the output is not just an AI-generated explanation sitting outside the spreadsheet.</p><p>The work is being performed inside the environment where the data already exists.</p><p>Imagine that Copilot tells me that the West region has the lowest gross margin.</p><p>That is useful, but I may still want to know how it arrived at that conclusion.</p><p>If Copilot has created the calculations and summary inside the workbook, I can inspect them. I can look at the source data, check the formulas, change the PivotTable, or modify the chart.</p><p>This is important because spreadsheets have always been valuable partly because their calculations are inspectable.</p><p>The agent can help construct the analysis without taking away that underlying structure.</p><h3>PivotTables and charts become part of the agent’s workflow</h3><p>This becomes even more useful when you look at PivotTables.</p><p>For many Excel users, creating a PivotTable is second nature. But there is still a mental step involved: you have to recognize that a PivotTable is the appropriate tool for the question you are asking.</p><p>Suppose my workbook contains sales transactions across several months.</p><p>I want to know which regions generated the most revenue, which had the best margins, and whether those margins are improving or declining.</p><p>I could manually create a PivotTable with Region as the row, Month as the column, and the relevant measures as values.</p><p>Or I can describe what I want to see.</p><p>Copilot can then use Excel’s existing structures to produce that analysis.</p><p>The same idea applies to charts.</p><p>A chart is useful because it makes certain patterns easier to see. But choosing the right chart, selecting the correct data, positioning it properly, and keeping it connected to the underlying analysis all take time.</p><p>The newer Copilot capabilities around charts and PivotTables push more of that work into the agent’s workflow.</p><p>This is where I think AI inside Excel becomes genuinely useful: not because it replaces Excel’s features, but because it can coordinate several of them.</p><h3>Python gives the agent another tool</h3><p>There is another part of the recent Excel changes that I find particularly interesting: Python.</p><p>Python has already become part of the Excel ecosystem, but Microsoft is now bringing Python into the Copilot editing workflow for more advanced analysis.</p><p>That matters because there is a limit to how comfortable some analytical tasks are in ordinary spreadsheet formulas.</p><p>Suppose I have thousands of transactions and I want to investigate unusual values, perform statistical analysis, simulate different scenarios, or produce a more advanced visualization.</p><p>I could manually build the analysis in Excel.</p><p>I could export the data and use Python separately.</p><p>Or, where the capability is available, Copilot can use Python as part of the analysis.</p><p>For example, I could ask:</p><pre>Analyse the distribution of sales values, identify unusual<br>transactions, and create a visualization showing the outliers.</pre><p>The interesting part is not simply that Excel can run Python.</p><p>It is that Python can become another tool available to the agent when the task requires something beyond basic spreadsheet operations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qg8fPnB5P3eC8SZiyVqsQQ.png" /><figcaption>A diagram showing Copilot sitting above Excel, using formulas, tables, PivotTables, and charts for standard tasks and Python for advanced analysis, while all results remain connected to the workbook.</figcaption></figure><p>This gives Copilot a much larger range of possible operations.</p><p>A simple request might only require formulas.</p><p>Another might require a PivotTable.</p><p>A more advanced analytical request could benefit from Python.</p><p>The user does not necessarily need to know which tool should be used beforehand.</p><h3>The harder problem is not generating the formula</h3><p>There is a reason I would still be careful with all of this.</p><p>Excel is fundamentally deterministic.</p><p>If I write a formula such as:</p><pre>=SUM(B2:B100)</pre><p>and the values in B2:B100 have not changed, I expect the result to remain the same.</p><p>That predictability is extremely important.</p><p>Generative AI works differently. The model is probabilistic, which means there is a fundamental difference between asking an AI system to help construct a spreadsheet and making the AI itself part of the spreadsheet’s core calculation layer.</p><p>This is one reason I find Microsoft’s decision around the experimental =COPILOT() worksheet function particularly interesting.</p><p>The idea of putting a generative AI function directly into a cell sounds convenient. But it also raises questions about reproducibility.</p><p>What should happen when a cell containing an AI-generated result needs to produce exactly the same answer tomorrow?</p><p>What happens when the prompt stays the same but the underlying model changes?</p><p>What happens when someone needs to audit how that result was produced?</p><p>Those are very different requirements from the ones we normally place on Excel formulas.</p><p>Microsoft is retiring the experimental =COPILOT() worksheet function while continuing to invest in the broader Copilot experience inside Excel.</p><p>To me, that direction makes more sense.</p><p>The AI can operate above the spreadsheet’s deterministic calculation engine rather than becoming the calculation engine itself.</p><p>Copilot can reason about what needs to happen, use Excel’s tools to make the changes, and leave behind formulas, tables, PivotTables, and charts that can still be inspected normally.</p><h3>The more powerful the agent becomes, the more important verification becomes</h3><p>There is another problem that comes with giving an AI permission to edit a workbook.</p><p>It can make a lot of changes very quickly.</p><p>That is obviously useful, but it also means I need to understand what happened afterward.</p><p>Imagine asking Copilot to update a financial report.</p><p>It changes several formulas, adds a summary, creates a PivotTable, and modifies a chart.</p><p>Everything looks fine.</p><p>The next day, I notice that one number does not look right.</p><p>This is where Microsoft’s work around change history becomes important.</p><p>Copilot can now help summarize changes made to a workbook and identify changes made by people or by Copilot. That gives the user another way to understand how the workbook got from one state to another.</p><p>This is not just a nice productivity feature.</p><p>It becomes increasingly important as software gets more autonomy.</p><p>When I manually change five cells, I generally know what I changed.</p><p>When an agent performs twenty operations on my behalf, I need the system to help me reconstruct what happened.</p><p>The more capable the agent becomes, the more important that auditability becomes.</p><h3>Where I would actually use an Excel agent</h3><p>I would not use Copilot just because it can write a formula I could write myself in five seconds.</p><p>The biggest value is in tasks where several operations have to happen together.</p><p>Monthly reporting is a good example.</p><p>The source data changes every month, but the structure of the report remains largely the same. I might need to clean incoming data, calculate additional metrics, summarize the results, compare them with previous periods, and update the charts.</p><p>That is a workflow.</p><p>Another useful case is exploring a dataset I have never worked with before.</p><p>I might not know exactly which questions I should ask yet. Instead of manually inspecting thousands of rows, I can ask Copilot to summarize the data, identify unusual patterns, compare categories, and suggest useful ways to visualize the results.</p><p>The AI becomes useful because it reduces the amount of mechanical work between having a question and getting to something I can investigate.</p><p>That is very different from asking it to make an important business decision for me.</p><h3>What I would still verify myself</h3><p>I would be much more careful when the workbook is being used for something where a wrong result has serious consequences.</p><p>Financial reporting is an obvious example.</p><p>So are compliance calculations, important forecasts, and analyses where the assumptions are complicated or business-specific.</p><p>The problem may not even be the formula.</p><p>Copilot could generate a perfectly valid Excel formula while misunderstanding what the business actually means by a particular metric.</p><p>For example, suppose the company defines gross margin using a specific set of costs that are not obvious from the column names.</p><p>Copilot could calculate the mathematically correct result from the wrong definition.</p><p>That is why I think the right way to use an Excel agent is not to remove human judgment completely.</p><p>Let the agent handle the repetitive construction work.</p><p>Then inspect the important parts.</p><p>Check the assumptions.</p><p>Look at the formulas.</p><p>Validate the output against something you already know to be correct.</p><p>The goal is not to blindly trust the AI. The goal is to spend less time performing mechanical spreadsheet operations and more time reviewing the analysis that actually matters.</p><h3>Excel is becoming an agent, but it is still Excel</h3><p>After looking at all of these changes together, I don’t think the interesting story is simply that Microsoft has added AI to Excel.</p><p>Excel has had AI features for some time.</p><p>The bigger shift is that Copilot is moving from answering questions about a workbook toward actually working with the workbook.</p><p>It can take a natural-language request, plan a sequence of operations, use Excel’s existing capabilities, create formulas and other workbook objects, build PivotTables and charts, use Python for more advanced analysis, and help the user understand changes made along the way.</p><p>That changes the relationship between the user and the spreadsheet.</p><p>You no longer always have to start by asking, “Which Excel feature should I use?”</p><p>You can start with, “What am I trying to find?”</p><p>The agent can help translate that outcome into the operations required to get there.</p><p>But the important thing is that the final result is still sitting inside Excel.</p><p>The formulas are still formulas.</p><p>The data is still there.</p><p>The PivotTable can still be inspected.</p><p>The chart can still be changed.</p><p>And the user can still question the result.</p><p>That is probably the direction I find most interesting.</p><p>Microsoft is not replacing Excel with a chatbot.</p><p>It is putting an agent on top of one of the world’s most widely used data tools and giving that agent access to the tools Excel users already rely on.</p><p>For simple spreadsheet work, that may not change much.</p><p>For larger, repetitive analysis workflows, it could change how people work with Excel entirely.</p><p>The spreadsheet is still the spreadsheet.</p><p>The difference is that, increasingly, you can tell it what you want to accomplish instead of explaining every step required to get there.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b90741f58f4d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Connecting a Fabric Data Agent to a Foundry Agent]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/connecting-a-fabric-data-agent-to-a-foundry-agent-a74529c249ad?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/a74529c249ad</guid>
            <category><![CDATA[azureaifoundry]]></category>
            <category><![CDATA[foundry]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 06:09:24 GMT</pubDate>
            <atom:updated>2026-08-23T06:09:24.292Z</atom:updated>
            <content:encoded><![CDATA[<p>You’ve got a Fabric data agent that works. It’s published, it answers questions about your data, and people can use it.</p><p>Now someone wants that same data agent to live inside a Microsoft Foundry agent.</p><p>You open Foundry, start setting up the connection, and suddenly you&#39;re being asked for things like a <strong>workspace ID</strong> and an <strong>artifact ID</strong>.</p><p>The actual connection is fairly simple. You publish the Fabric data agent, take the two IDs from its URL, create the Microsoft Fabric connection in your Foundry project, and give your agent access to it.</p><p>The part that can cost you time is what happens after the connection succeeds.</p><p>You can have a perfectly valid connection and still get no useful data back because the person asking the question doesn&#39;t have the right permissions in Fabric.</p><p>That is the part worth understanding before you start blaming the connection.</p><blockquote><strong><em>Note:</em></strong><em> The Fabric data agent integration with Foundry is currently in preview, so the exact portal and SDK experience can change.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uFzWFQhLs-nFU5UlqyVG1g.png" /><figcaption>Architecture showing a user asking a Foundry agent a question, with the agent calling a Fabric tool that invokes a Fabric data agent connected to Fabric data sources.</figcaption></figure><h3>Before you connect anything</h3><p>There are a few things that need to be true first.</p><p>Your Fabric data agent needs to be <strong>published</strong>. Building and testing an agent in Fabric isn&#39;t enough. The Foundry integration connects to the published data agent, so if it isn&#39;t published, there isn&#39;t a usable endpoint for Foundry to consume.</p><p>You also need an appropriate Fabric capacity. Microsoft currently documents F2 or higher capacity, or Power BI Premium capacity P1 or higher with Fabric enabled, for this scenario.</p><p>Your Fabric tenant needs the relevant data-agent settings enabled as well. Depending on where your data and processing are located, cross-geo AI settings can matter too.</p><p>And, obviously, there needs to be actual data behind the agent.</p><p>A published agent connected to an empty or inaccessible data source isn&#39;t very useful, and it can be surprisingly easy to mistake a permissions problem for a broken agent.</p><p>Finally, the Foundry project and Fabric data agent need to be in the same Microsoft Entra tenant. Different Azure regions are supported, but cross-tenant scenarios aren&#39;t.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NyOqgKMWnRwv5WdTth2xBA.png" /><figcaption>Prerequisites for connecting a Fabric data agent to a Foundry agent, including publication, capacity, tenant settings, data access, and Entra tenant alignment.</figcaption></figure><h3>Get the two IDs from Fabric</h3><p>Start in Fabric.</p><p>Build your data agent, connect it to the data you want it to work with, and test it there first.</p><p>This is important.</p><p>Don&#39;t connect a data agent to Foundry just because it exists. Ask it a few questions in Fabric and make sure it is actually producing the answers you expect.</p><p>Once you&#39;re happy with it, publish the agent.</p><p>The published endpoint contains the values Foundry needs. It follows a structure similar to:</p><pre>https://&lt;environment&gt;.fabric.microsoft.com/groups/&lt;workspace_id&gt;/aiskills/&lt;artifact_id&gt;</pre><p>The value after /groups/ is your <strong>workspace ID</strong>.</p><p>The value after /aiskills/ is your <strong>artifact ID</strong>.</p><p>You don&#39;t need to generate either value yourself. They&#39;re already part of the published data-agent URL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FwxIoxKekGK4mtif_gca3A.png" /><figcaption>Annotated Fabric data agent URL showing the workspace ID after /groups/ and the artifact ID after /aiskills/.</figcaption></figure><h3>Create the Fabric connection in Foundry</h3><p>Now move over to your Foundry project.</p><p>The current Foundry flow is based around creating a <strong>Microsoft Fabric connection</strong> in the project&#39;s connected resources and then giving your agent access to that connection.</p><p>Create the connection and provide the workspace ID and artifact ID you copied from Fabric.</p><p>Give the connection a useful name.</p><p>Something like:</p><p>fabric-sales-agent</p><p>is much better than:</p><p>connection1</p><p>because you may eventually have several connections and several agents.</p><p>Once the connection is created, Foundry has a reference to your published Fabric data agent.</p><p>That&#39;s the wiring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OGb2T_FIQLpzSkSg9bjcQw.png" /><figcaption>Diagram showing a Foundry project creating a Microsoft Fabric connection from a workspace ID and artifact ID and making that connection available to a Foundry agent.</figcaption></figure><h3>Tell the agent when to use Fabric</h3><p>Creating the connection doesn&#39;t automatically mean your agent will use it correctly.</p><p>The Fabric connection becomes a tool that the agent can call when it needs information from your Fabric data agent.</p><p>That means the agent&#39;s instructions matter.</p><p>If your agent is supposed to answer questions about customers, products and sales, say that explicitly.</p><p><strong>For example:</strong></p><blockquote><em>For questions about customers, products, sales, revenue, or other information contained in the Fabric data source, use the Microsoft Fabric tool before answering. Do not answer from assumptions when the required information can be retrieved from Fabric.</em></blockquote><p>That instruction is much better than simply saying:</p><blockquote><em>You have access to Fabric.</em></blockquote><p>The second statement tells the model that the tool exists.</p><p>The first tells it <strong>when you expect it to use it</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b4IpdhSafqu5fEHzAONFaA.png" /><figcaption>Decision flow showing a Foundry agent using the Fabric tool for questions that require data from Fabric while handling other questions normally.</figcaption></figure><p>Then open the Playground and ask a question you already know the answer to.</p><p>For example:</p><blockquote><em>What were total sales by region last quarter?</em></blockquote><p>Watch the tool activity.</p><p>You want to see the agent actually call the Fabric data agent rather than simply generating an answer from the model&#39;s own knowledge.</p><p>If the agent answers immediately without calling Fabric, don&#39;t assume the connection is broken.</p><p>Look at the instructions first.</p><p>The model may simply have decided that it could answer without using the tool.</p><p>Make the tool-selection instructions more explicit and test again.</p><h3>The identity part is more important than the connection</h3><p>This is the bit that can cause the most confusion.</p><p>The Fabric tool doesn&#39;t simply connect to Fabric as some anonymous application identity and start reading everything the data agent can see.</p><p>The current Foundry integration uses the <strong>signed-in user&#39;s identity</strong> when the Fabric tool runs. Microsoft describes this as identity passthrough.</p><p>That means the user asking the question needs access to the Fabric data agent and the underlying data source.</p><p>For example, if Alice can access the data but Bob can&#39;t, the agent shouldn&#39;t magically give Bob Alice&#39;s data.</p><p>The Fabric permissions still matter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XQatQpXPa4D5jzXNqcquYw.png" /><figcaption>Diagram illustrating identity passthrough, where different users querying the same Foundry agent receive access according to their own Fabric permissions.</figcaption></figure><p>This is why a connection can look completely healthy while the agent still can&#39;t answer a question.</p><p>The connection exists.</p><p>The tool exists.</p><p>The agent can see the tool.</p><p>But the person making the request doesn&#39;t have permission to see the data.</p><p>And the result can look like a mysterious agent failure.</p><p>So when debugging this, test the exact same user directly against the Fabric data agent first.</p><p>If that user can&#39;t get the answer in Fabric, don&#39;t start debugging Foundry.</p><p>Fix the Fabric permissions.</p><h3>And this is why service principals are different</h3><p>There is an easy source of confusion here because Fabric data agents themselves have a separate service-principal authentication capability in preview.</p><p>But that is <strong>not the same thing as the Foundry Fabric tool integration</strong>.</p><p>For the current Foundry Fabric tool, Microsoft documents user identity authentication and says service-principal authentication isn&#39;t supported for this integration.</p><p>So if you&#39;re building an unattended architecture and thinking:</p><blockquote><em>&quot;I&#39;ll just give my Foundry agent a service principal and let it query Fabric.&quot;</em></blockquote><p>Stop there.</p><p>That&#39;s a different authentication scenario.</p><p>The current Foundry integration is designed around the end user&#39;s identity being passed through to Fabric.</p><p>That distinction matters when you&#39;re designing the architecture rather than just getting the demo working.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4oK4ESlDricEzQwRgzSmQA.png" /><figcaption>Comparison showing that the Foundry Fabric tool uses the signed-in user’s identity, while separate Fabric data-agent scenarios can support application identities.</figcaption></figure><h3>Doing it with Python</h3><p>Once the portal setup works, you can use the SDK instead.</p><p>The basic pattern is to create an AIProjectClient, resolve your Fabric connection, create a FabricTool, and attach its definitions to the agent.</p><p>A simplified version looks like this:</p><pre>import os<br><br>from azure.ai.projects import AIProjectClient<br>from azure.ai.agents.models import FabricTool, ListSortOrder<br>from azure.identity import DefaultAzureCredential<br><br><br>project = AIProjectClient(<br>    endpoint=os.environ[&quot;PROJECT_ENDPOINT&quot;],<br>    credential=DefaultAzureCredential(),<br>)<br><br>fabric_connection = project.connections.get(<br>    os.environ[&quot;FABRIC_CONNECTION_NAME&quot;]<br>)<br><br>fabric = FabricTool(<br>    connection_id=fabric_connection.id<br>)<br><br>with project:<br>    agent = project.agents.create_agent(<br>        model=os.environ[&quot;MODEL_DEPLOYMENT_NAME&quot;],<br>        name=&quot;sales-agent&quot;,<br>        instructions=(<br>            &quot;For questions about customers, products, &quot;<br>            &quot;or sales, use the Fabric tool before answering.&quot;<br>        ),<br>        tools=fabric.definitions,<br>    )</pre><p>The important thing to notice is that the code doesn&#39;t contain a Fabric username and password.</p><p>You&#39;re referencing the Foundry project connection and letting the supported identity flow handle authentication.</p><p>Because this integration is in preview, check the current Microsoft SDK documentation before installing packages or copying an older code sample. Preview SDKs change quickly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YGKZ0YWYQIdmlinG8ZxsOw.png" /><figcaption>Diagram comparing portal and Python SDK approaches for connecting a Fabric data agent to a Foundry agent.</figcaption></figure><h3>If the connection works but the agent returns nothing</h3><p>This is where I&#39;d start debugging.</p><p>First, make sure the Fabric data agent is still published.</p><p>Then check the identity.</p><p>Is the person using the Foundry agent able to access the Fabric data agent directly?</p><p>Can they access the underlying lakehouse, warehouse, semantic model or other source?</p><p>If the answer to any of those is no, fix that before changing the Foundry configuration.</p><p>Also check the workspace ID and artifact ID.</p><p>If either value is wrong, recreate the connection using the IDs from the published data-agent URL.</p><p>And finally, check the agent&#39;s instructions.</p><p>A tool can be perfectly connected and still not be called if the agent doesn&#39;t think it needs it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*LWfdDHNXdG88BSB-D7fbXg.png" /><figcaption>Troubleshooting decision tree for a Foundry agent that connects to a Fabric data agent but returns no data.</figcaption></figure><h3>Don&#39;t think of the Fabric agent as a permission bypass</h3><p>The Fabric data agent sits on top of your Fabric data sources.</p><p>It doesn&#39;t magically make data available to users who couldn&#39;t access it before.</p><p>That&#39;s actually one of the better parts of this architecture.</p><p>You don&#39;t have to rebuild every Fabric permission and security rule inside your Foundry agent.</p><p>The user&#39;s identity and Fabric permissions remain part of the request.</p><p>If your users have different access to different data, that distinction becomes particularly important.</p><p>The Foundry agent is effectively giving the user another conversational interface to the data they already have permission to access.</p><h3>The architecture is simpler than it first looks</h3><p>Once you strip away the portal screens and preview terminology, the flow is pretty straightforward:</p><p><strong>User → Foundry Agent → Fabric Tool → Fabric Data Agent → Fabric Data</strong></p><p>The Foundry agent decides when it needs the Fabric tool.</p><p>The Fabric data agent handles the natural-language question against the configured Fabric data.</p><p>And the request uses the user&#39;s identity, so access to the underlying data still matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c63lPCyHgZAYU-WwqmmT8g.png" /><figcaption>End-to-end architecture for connecting a Microsoft Foundry agent to a Fabric data agent, showing the user’s identity flowing through the Foundry agent and Fabric tool to Fabric data sources.</figcaption></figure><p>That&#39;s the part I think is worth understanding.</p><p>You&#39;re not copying the data into Foundry.</p><p>You&#39;re not building another SQL layer just so the agent can ask questions.</p><p>And you&#39;re not giving the Foundry agent unrestricted access to everything in your Fabric environment.</p><p>You&#39;re connecting an existing Fabric data agent as a tool.</p><p>The setup itself takes only a few minutes once you know where the IDs and connection live.</p><p>The harder part is understanding the boundaries: <strong>the agent must be published, the connection must point to the right workspace and artifact, the user needs access to the data, and the agent needs clear instructions about when to use the Fabric tool.</strong></p><p>Get those pieces right and the integration is surprisingly clean.</p><p>And if it connects successfully but gives you nothing back, don&#39;t immediately rebuild the whole thing.</p><p>Check the user&#39;s Fabric permissions first.</p><p>There&#39;s a good chance the connection isn&#39;t broken at all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a74529c249ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Matching “Almost the Same” Data in Excel with Power Query]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/matching-almost-the-same-data-in-excel-with-power-query-efebe636159f?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/efebe636159f</guid>
            <category><![CDATA[excel]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 05:52:25 GMT</pubDate>
            <atom:updated>2026-08-23T05:52:25.745Z</atom:updated>
            <content:encoded><![CDATA[<p>Last week, a VLOOKUP gave me #N/A down an entire column. Not one match.</p><p>The reason was stupid: one file had <strong>“Onyx Data Ltd”</strong> and the other had <strong>“Onyx Data Limited.”</strong> To a person looking at the two lists, there is nothing confusing about that. They are obviously the same company. But to Excel, they are two different strings, so the lookup gave up.</p><p>This is one of those problems you run into constantly when working with data from different systems. One system calls a company MTN Nig, another calls it MTN Nigeria. Someone types Microsft instead of Microsoft. One database stores GTBank, another stores Gtbank. Sometimes there is an extra space, a different abbreviation, or just a small typo.</p><p>An exact lookup doesn’t care.</p><p>It asks whether the two values are the same. If they aren’t, you get no match.</p><p>Power Query’s <strong>fuzzy matching</strong> is useful when the data is close enough that a human would recognise it, but not identical enough for a normal join. Instead of requiring two text values to be exactly equal, Power Query calculates how similar they are and lets you decide how similar they need to be before they count as a match.</p><p>The similarity threshold ranges from 0 to 1 and defaults to 0.8.</p><p>It isn’t magic, and you shouldn’t treat it like one. But for messy names and other text fields, it can save a ridiculous amount of manual cleanup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5iCDx8TNveVocWNFq07c8Q.png" /><figcaption>Comparison showing that Excel exact matching rejects ‘Onyx Data Ltd’ and ‘Onyx Data Limited’, while Power Query fuzzy matching can recognise them as similar.</figcaption></figure><h3>The problem with exact matching</h3><p>Let’s say I have two tables.</p><p>My first table contains payments:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*zWS842ZdI8C7iaZKLCR4Bw.png" /></figure><p>My second table is the vendor master:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*6kaALMdz_vxFPLzLUv3X7A.png" /></figure><p>If I use an exact lookup, GTBank might work, but the others can fail because the text isn&#39;t identical.</p><p>That becomes particularly annoying when you’re dealing with hundreds or thousands of rows. You could clean the names manually, but then you’ll probably have to do the same thing again when the next file arrives.</p><p>This is where fuzzy matching makes more sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k1412dYUzDipueTaHz7eAg.png" /><figcaption>Power Query fuzzy merge connecting inconsistent vendor names in a payments table to their corresponding names in a clean vendor master table.</figcaption></figure><h3>Getting the tables into Power Query</h3><p>First, turn both datasets into proper Excel Tables. Select each range and press <strong>Ctrl + T</strong>.</p><p>I’ll call my two tables Payments and Vendors.</p><p>Then load the Payments table into Power Query using <strong>Data → From Table/Range</strong>. Do the same for the vendor master, although I normally keep a master/reference table as <strong>Connection Only</strong> if I don&#39;t need to load it separately into the worksheet.</p><p>The important thing is that both tables are now available inside Power Query.</p><p>From the Payments query, go to <strong>Home → Merge Queries</strong>.</p><p>Select Vendors as the second table and select the vendor-name column in both tables.</p><p>For this example, I’m using a <strong>Left Outer</strong> join because I want to keep every payment, even when Power Query can’t find a corresponding vendor.</p><p>Now enable:</p><p><strong>Use fuzzy matching to perform the merge</strong></p><p>This is the setting that changes the whole thing.</p><p>Instead of asking whether Onyx Data Ltd exactly equals Onyx Data Limited, Power Query can now look for a sufficiently similar value in the other table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9f0s-NId6Eb7DE7XqSPftQ.png" /><figcaption>Diagram showing a Power Query left outer merge between Payments and Vendors with fuzzy matching enabled on the vendor columns.</figcaption></figure><h3>Adjusting the similarity threshold</h3><p>Once fuzzy matching is enabled, open the fuzzy matching options.</p><p>You’ll see a <strong>Similarity Threshold</strong>.</p><p>This controls how similar two values need to be before Power Query considers them a match. The default is 0.8. A higher value makes the match stricter; a lower value allows more differences.</p><p>I usually don’t treat 0.8 as some magic number.</p><p>It depends on the data.</p><p>For my example, I might lower it to 0.7 and see what happens.</p><p>The important part is to look at the results rather than simply lowering the threshold until every row matches.</p><p>You don’t want to optimise for the number of matches.</p><p>You want to optimise for the number of <strong>correct</strong> matches.</p><p>That’s an important distinction.</p><p>A threshold that is too high can leave genuine matches unmatched. A threshold that is too low can start matching things that merely look similar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XFMDVB2URKDI8z4Ci1x-mA.png" /><figcaption>Diagram illustrating how Power Query similarity thresholds trade off between stricter matching and more aggressive matching.</figcaption></figure><h3>What if fuzzy matching still can’t find the match?</h3><p>This is where the transformation table becomes useful.</p><p>Suppose Power Query still refuses to match:</p><p>MTN Nig</p><p>with:</p><p>MTN Nigeria</p><p>You can keep lowering the threshold, but that isn’t necessarily going to solve the underlying problem.</p><p>Nig is an abbreviation.</p><p>The algorithm doesn’t automatically know that your organisation uses Nig to mean Nigeria.</p><p>So instead of asking Power Query to guess, you can tell it.</p><p>Create another small Excel table with two columns named <strong>From</strong> and <strong>To</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*Ub6qziStJg9VvOPwStOMQA.png" /></figure><p>Load that table into Power Query.</p><p>Then select it as the <strong>Transformation Table</strong> in the fuzzy matching options.</p><p>Power Query can use those mappings before performing the fuzzy comparison.</p><p>Now MTN Nig can be transformed using the rule we supplied, making it much easier to match against MTN Nigeria.</p><p>The same idea works for Onyx Data Ltd and Onyx Data Limited.</p><p>This is one of my favourite parts of fuzzy matching because you aren’t just lowering the matching threshold and hoping for the best. You’re adding knowledge about how <strong>your particular data</strong> is written.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LOErPXyeCThFpGz9BCZM6w.png" /><figcaption>Power Query transformation table replacing vendor abbreviations such as ‘Nig’ and ‘Ltd’ with their standard forms before fuzzy matching.</figcaption></figure><h3>One thing about transformation tables that can catch you out</h3><p>There is a slightly unintuitive detail here.</p><p>When a transformation table is used, the similarity score for those transformed values is capped at <strong>0.95</strong>.</p><p>So if you use a transformation table and then set your threshold above 0.95, you can end up excluding those transformed matches.</p><p>If you need the transformation to behave as an actual replacement before fuzzy matching, rather than taking the transformation-table penalty, replace the values first and then run the fuzzy match.</p><p>That’s a small detail, but it is exactly the sort of thing that can make you wonder why a rule you explicitly created isn’t working.</p><h3>What’s happening underneath?</h3><p>If you open Power Query’s Advanced Editor, the merge you created through the interface is represented by M code using Table.FuzzyNestedJoin.</p><p>The options you selected in the UI are passed into that function.</p><p>For example:</p><pre>[<br>    IgnoreCase=true,<br>    IgnoreSpace=true,<br>    Threshold=0.7,<br>    NumberOfMatches=1,<br>    TransformationTable=VendorFixes<br>]</pre><p>You don’t need to write this code yourself to use fuzzy matching. The interface handles the basic setup.</p><p>But knowing what is happening underneath is useful when you eventually need something the UI doesn’t expose cleanly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gTWKpt62N8O2rlVu-_E33A.png" /><figcaption>Diagram mapping Power Query fuzzy matching settings in the interface to their corresponding M code parameters.</figcaption></figure><h3>Be careful with the number of matches</h3><p>There is another setting I would pay attention to: <strong>Maximum number of matches</strong>.</p><p>If I’m matching payments to a vendor master and I expect each payment to belong to one vendor, I normally set this to 1.</p><p>Why?</p><p>Because if you allow multiple matches, one messy vendor name can potentially return several rows from the master table.</p><p>Once you expand the result, that single payment can become multiple rows.</p><p>Your query can still refresh successfully.</p><p>Your Excel formulas can still calculate successfully.</p><p>Your totals can still look perfectly normal.</p><p>They’re just wrong.</p><p>That’s a particularly dangerous type of data problem because nothing technically failed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FZ3TvI4aAee2oQ1k9-3Nhg.png" /><figcaption>Diagram showing how one payment can become multiple rows when a fuzzy match returns several possible vendors, potentially inflating totals.</figcaption></figure><h3>Don’t just look at whether a match exists</h3><p>When I’m testing a fuzzy merge, I also want to know <strong>how good the match was</strong>.</p><p>That’s where the similarity score is useful.</p><p>Power Query can add a similarity column using SimilarityColumnName in the M code.</p><p>Once you have that, sort the results by the score and inspect the weaker matches.</p><p>The high-scoring matches are usually straightforward.</p><p>The ones near your threshold deserve more attention.</p><p>The similarity score isn’t proof that a match is correct. It is another signal you can use to decide which rows need human review.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D0fZdw3DGjO9pquLaNEIXg.png" /><figcaption>Example fuzzy matching results sorted by similarity score, showing high-confidence matches and lower-confidence rows that need manual review.</figcaption></figure><h3>Clean the data before fuzzy matching</h3><p>Fuzzy matching is useful, but don’t make it solve problems that basic cleaning can solve.</p><p>Before you turn it on, clean the obvious stuff.</p><p>Trim unnecessary spaces.</p><p>Remove non-printing characters.</p><p>Standardise casing where appropriate.</p><p>Clean up known abbreviations.</p><p>Remove unnecessary suffixes such as Ltd, Inc or Plc if they aren&#39;t useful to your matching logic.</p><p>Every difference you remove before fuzzy matching is one less difference the algorithm has to deal with.</p><p>This is also why I wouldn’t immediately set the threshold very low.</p><p>If you can fix the data properly, fix it.</p><p>Use fuzzy matching for the differences that genuinely need fuzzy matching.</p><h3>When you should not use fuzzy matching</h3><p>Fuzzy matching is great for messy names.</p><p>It is a terrible idea for many identifiers.</p><p>If you’re matching invoice numbers, customer IDs, account numbers, employee IDs or product SKUs, use an exact match.</p><p>Consider these two values:</p><p>INV-1001</p><p>and:</p><p>INV-1002</p><p>They are very similar as text.</p><p>They are also completely different invoices.</p><p>The same applies to email addresses.</p><p>If the field is designed to uniquely identify something, similarity is not what you’re looking for.</p><p>This is the distinction I keep in mind:</p><p><strong>Use exact matching when the value itself is the identity.</strong></p><p><strong>Use fuzzy matching when the text is a representation of the identity and that representation can vary.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*orHwWjThZdTMZhrbdR7G3g.png" /><figcaption>Decision diagram showing when to use exact matching for unique identifiers and fuzzy matching for variable text such as names and addresses.</figcaption></figure><h3>The workflow I use</h3><p>When I receive two datasets that need to be joined, I generally don’t start with fuzzy matching.</p><p>I start with the simplest thing that can work.</p><p>First, clean the data.</p><p>Then try an exact match.</p><p>If the data is consistent enough, you’re done.</p><p>If the values represent the same entities but contain spelling differences, abbreviations or other variations, that’s when I reach for fuzzy matching.</p><p>If there are organisation-specific abbreviations that Power Query can’t reasonably infer, I add a transformation table.</p><p>Then I limit the number of matches, inspect the weaker similarity scores, and manually review anything suspicious.</p><p>The workflow is basically:</p><p><strong>Clean → Exact Match → Fuzzy Match → Transform Known Variations → Review → Load</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9vFYaeRlpZ5jNpJf3oXvrw.png" /><figcaption>Power Query data-matching workflow from cleaning and exact matching through fuzzy matching, transformation rules, review, and final output.</figcaption></figure><h3>The real advantage is what happens next month</h3><p>This is the part I think is easy to miss.</p><p>The biggest benefit of fuzzy matching isn’t that Power Query can recognise that Ltd and Limited are similar.</p><p>It’s that you don’t have to manually fix the same problems every time the data arrives.</p><p>If your vendor system gives you MTN Nig every month and your master system says MTN Nigeria, you can teach Power Query that rule once.</p><p>Next month, you refresh the query.</p><p>The transformation table is still there.</p><p>The fuzzy merge is still there.</p><p>The cleaning steps are still there.</p><p>You don’t have to spend another afternoon changing vendor names by hand.</p><p>And that is where Power Query becomes much more interesting than a replacement for VLOOKUP.</p><p>You’re building a repeatable data-cleaning process.</p><p>Real-world data is messy. Different systems use different names, people make typos, abbreviations creep in, and databases rarely agree perfectly.</p><p>Exact matching is still the right tool when you have reliable identifiers.</p><p>But when you’re working with messy text, fuzzy matching gives you a way to handle the gap between <strong>“exactly the same”</strong> and <strong>“obviously the same to a human.”</strong></p><p>So the next time Onyx Data Ltd refuses to match Onyx Data Limited, you don&#39;t necessarily need another VLOOKUP.</p><p>You might just need Power Query to be a little less literal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efebe636159f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Use Copilot in Excel Without Getting Burned]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/how-to-use-copilot-in-excel-without-getting-burned-c9a7378e1f76?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9a7378e1f76</guid>
            <category><![CDATA[excel]]></category>
            <category><![CDATA[co-pilot]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 12:02:41 GMT</pubDate>
            <atom:updated>2026-08-15T12:02:41.328Z</atom:updated>
            <content:encoded><![CDATA[<p>Copilot in Excel can now do more than answer questions about your workbook.</p><p>It can actually go in and do things.</p><p>That’s the useful part.</p><p>It’s also the part that should make you a little more careful.</p><p>Because when Copilot changes something, calculates something, or builds something for you, the final number can look completely reasonable while you have no idea how it got there.</p><p>And that’s the problem.</p><p>Here’s how I’d actually use it — and what I’d check before trusting the result.</p><h3>First: you no longer need AutoSave on</h3><p>Almost every Copilot in Excel guide you’ll find online says the same thing: your file has to be in OneDrive and AutoSave has to be on.</p><p>That used to be true.</p><p>And honestly, it was one of the most annoying parts of using Copilot, especially if you were working on a draft or a sensitive model and didn’t want every change syncing to everyone else while you were still figuring things out.</p><p>That changed with the July 2026 update.</p><p>Copilot in Excel now works on both Windows and Mac with AutoSave turned off.</p><p>Microsoft still recommends keeping AutoSave on when you’re collaborating, but it’s no longer a requirement. In fact, Microsoft now suggests turning it off when you want to experiment with Copilot-generated changes without having them automatically committed.</p><p>That’s actually a pretty good habit.</p><p>The annoying part is that the documentation hasn’t caught up everywhere. You can still find support pages that look current but say AutoSave is mandatory.</p><p>So if Copilot isn’t working for you, check that Excel is actually updated before assuming the feature is broken.</p><p>There’s one requirement that hasn’t changed, though.</p><p>If your workbook has a <strong>Confidential</strong> or <strong>Highly Confidential</strong> sensitivity label, some Copilot actions are blocked, including formula generation.</p><p>So if the Copilot buttons are greyed out and everything else looks right, check the sensitivity label first.</p><h3>Your data should be a table</h3><p>This is probably the number one reason Copilot gives you something useless.</p><p>And it takes about two seconds to fix.</p><p>Select your data and hit <strong>Ctrl+T</strong>.</p><p>That’s it.</p><p>You’ve just turned a random range of cells into an Excel Table, which gives Copilot a much better idea of what it’s looking at: where the data starts, where it ends, and which row contains the headers.</p><p>Without that, it has to make more guesses based on blank rows, formatting, and whatever else is sitting around your sheet.</p><p>With a table, the boundaries are explicit. And when you add more rows later, the table expands with them.</p><p>While you’re there, fix two other things.</p><p><strong>Unmerge your header cells.</strong></p><p>Merged cells can confuse Copilot when it’s trying to understand the structure of your data.</p><p>If you have <strong>“Q1”</strong> merged across three month columns, split it into a proper <strong>Period</strong> column and repeat the value on each row.</p><p>It looks uglier.</p><p>It works better.</p><p><strong>And give your columns real names.</strong></p><p>“Revenue” is useful.</p><p>“Col_4” tells Copilot basically nothing.</p><p>Copilot uses your column headers to understand what the data actually means. The clearer those names are, the less it has to guess.</p><h3>Ask for a job, not for “analysis”</h3><p>“Analyze this spreadsheet” sounds like a reasonable prompt.</p><p>It isn’t.</p><p>Analyze what?</p><p>Trends? Outliers? Missing values? Top customers?</p><p>Copilot has to pick something, and there’s a good chance it won’t be what you actually wanted.</p><p>Compare:</p><blockquote>Analyze my sales data</blockquote><p>with:</p><blockquote>Find duplicate order IDs, normalise the Region column, and show me the five customers with the highest July revenue, excluding cancelled orders.</blockquote><p>The second one has edges.</p><p>You’ve told Copilot what to look for, what to ignore, and what you want back.</p><p>That’s the trick.</p><p>Name the columns. State your filters. Say what the output should look like.</p><p>The more specific you are, the less room you leave for Copilot to make things up.</p><h3>Get it to show the Python</h3><p>This is the single most useful habit and hardly anyone does it.</p><p>Instead of accepting a chat answer, ask Copilot to do the analysis in Python. You’ll get something like this dropped into your sheet:</p><pre>import pandas as pd<br>df = xl(&quot;Sales[#All]&quot;, headers=True)<br>df[&quot;Date&quot;] = pd.to_datetime(df[&quot;Date&quot;], errors=&quot;coerce&quot;)<br>df = df[(df[&quot;Date&quot;].dt.month == 7) &amp; (df[&quot;Date&quot;].dt.year == 2026)]<br>df = df[df[&quot;Status&quot;] != &quot;Cancelled&quot;]<br>top = (df.groupby(&quot;Customer&quot;, as_index=False)[&quot;Revenue&quot;]<br>         .sum()<br>         .sort_values(&quot;Revenue&quot;, ascending=False)<br>         .head(5))<br>top</pre><p>Now you can see what it actually did. Cancelled orders excluded, line seven. Unparseable dates coerced rather than silently kept. Grouped on Customer.</p><p>That last one matters. If your file has “Acme Ltd”, “Acme Limited” and “ACME LTD”, grouping on Customer treats them as three different companies, and your top-customer number is wrong. You’d never spot that from a chat message. You spot it immediately from the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LCy56PgfT_c0kbF7LVI2dw.png" /><figcaption><em>A chat answer giving just a number, versus Python output showing the filters, date handling and grouping that produced it.</em></figcaption></figure><p>Also new in July: Copilot now adds inline citations to its answers, pointing at the ranges it drew from. Use them. They’re the fastest way to check it looked at the columns you meant rather than something adjacent.</p><h3>Check the number against your own</h3><p>For anything that leaves your screen, recompute it separately.</p><pre>june = df[df[&quot;Month&quot;] == &quot;June&quot;]<br>july = df[df[&quot;Month&quot;] == &quot;July&quot;]<br>j1 = june.groupby(&quot;Region&quot;)[&quot;Revenue&quot;].sum()<br>j2 = july.groupby(&quot;Region&quot;)[&quot;Revenue&quot;].sum()<br>((j2 - j1) / j1) * 100</pre><p>If both agree, fine. If they don’t, you’ve learned something: maybe one excluded returns and the other didn’t, maybe there are rows with missing dates, maybe there are duplicate order IDs.</p><p>That takes a minute and it’s the difference between a number you can defend and one you’re hoping nobody asks about.</p><h3>The four things to check before you use its output</h3><p>Before you trust anything important, run through these.</p><p><strong>Did it use the column you actually meant?</strong></p><p>If you have both a <strong>Revenue</strong> column and a <strong>Quantity × Price</strong> calculation, Copilot might use the wrong one. The answer can still look perfectly reasonable.</p><p><strong>Did it catch the duplicates?</strong></p><p>Especially the annoying ones.</p><p>You might have Acme, ACME Ltd, and Acme Limited sitting in the same dataset.</p><p>Before trusting a total, group by the key column and count the records. You want to know what you’re actually counting.</p><p><strong>What did it do with the blanks?</strong></p><p>A blank revenue cell can be dropped, treated as zero, or left alone.</p><p>Those choices produce different answers.</p><p><strong>Did it accidentally include rows that aren’t data?</strong></p><p>Subtotal rows pasted into the middle of a table are ridiculously common. Copilot can see them as records and include them in the calculation.</p><p>And here’s the part that makes all of this dangerous:</p><p>None of these necessarily gives you an error.</p><p>You just get a number that’s slightly wrong.</p><p>That’s often worse.</p><h3>What it’s good at, and what it isn’t</h3><p>Copilot is actually pretty good at some of the boring Excel work.</p><p>Cleaning up inconsistent formatting.</p><p>Standardising text.</p><p>Finding duplicates and gaps.</p><p>Building the multi-step stuff that would normally take you six different formulas.</p><p>Even drafting Python for something you would otherwise have to go look up.</p><p>Where it gets shaky is when the data is messy in a way that needs actual judgement.</p><p>That’s the frustrating bit.</p><p>The cleaner your spreadsheet is, the better these tools tend to perform. Once the data gets genuinely messy, they start struggling — which is exactly when you’d really want the help.</p><p>You should also expect the occasional request that just… keeps running and never finishes.</p><p>And there’s one line I wouldn’t cross:</p><p><strong>Don’t make Copilot the final step before a decision involving money, compliance, or a customer.</strong></p><p>Not because it’s always wrong.</p><p>Because if someone asks, <em>“How did you get this number?”</em></p><p>“Copilot said so” isn’t an answer.</p><h3>Where Copilot sits</h3><p>It hasn’t replaced anything. It’s a layer on top that picks the tool for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QzBmYtnBbmE_41oTkT9o7g.png" /><figcaption><em>Copilot as a layer above formulas, Power Query, Python and charts, choosing between them and writing into the workbook.</em></figcaption></figure><p>Simple calculation is still a formula. Repeatable transformation is still Power Query. Heavy analysis is Python. Copilot just means you can ask in English and let it choose.</p><p>Which is also why knowing Excel matters more now, not less. If you can’t read a formula you can’t tell whether it wrote a good one. If you can’t read pandas, the generated Python is a wall of text you scroll past, and you’re back to trusting a chat message.</p><h3>The short version</h3><p>You don’t need AutoSave anymore, whatever the docs say. Format as a table. Unmerge your headers. Ask for a specific job with named columns. Get the Python. Follow the citations. Check for duplicates, blanks, and rows that aren’t data. Recompute anything important.</p><p>That’s about five extra minutes and it’s the difference between a fast answer and one you can stand behind.</p><p>What’s the check you always run before you trust a number in a spreadsheet?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9a7378e1f76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Is Your Foundry Agent Actually Acting As?]]></title>
            <link>https://medium.com/@izuafa123abdulrafiu/who-is-your-foundry-agent-actually-acting-as-2d31c69d0716?source=rss-1a7b4f3d5358------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d31c69d0716</guid>
            <category><![CDATA[foundry]]></category>
            <category><![CDATA[microsoft]]></category>
            <dc:creator><![CDATA[Abdulrafiu Izuafa]]></dc:creator>
            <pubDate>Sat, 15 Aug 2026 11:37:16 GMT</pubDate>
            <atom:updated>2026-08-15T11:37:16.479Z</atom:updated>
            <content:encoded><![CDATA[<p>Alice asks your sales agent to show her latest orders. It works. Bob asks the same question and gets his orders. Ship it.</p><p>Then someone asks a question you don’t have a good answer to: when the agent called the orders API, whose identity showed up on the other side?</p><p>If the answer is “Alice, then Bob,” fine. If the answer is “the agent, both times,” you don’t have per-user security. You have an agent with full access and a model that’s been politely asked to only return the right rows.</p><p>Those look identical in a demo. They’re completely different systems.</p><p>This gets more pressing now that Foundry agents can call authenticated MCP servers, invoke other agents over A2A, and reach whole tool collections through Toolboxes. The agent looks like one thing to your user. Underneath, it can be acting as something else entirely.</p><h3>The thing that isn’t an authorization mechanism</h3><p>Put this in a system prompt:</p><pre>The current user is Alice. Only return Alice&#39;s data.</pre><p>That’s an instruction to a model. It is not access control, and the distinction matters because the database doesn’t know what the model was told. It only knows what identity arrived on the connection.</p><p>If that identity is a shared service principal with broad read access, then every guardrail you have is a sentence in a prompt, and prompts are not a security boundary. They’re a suggestion the model usually follows.</p><p>So the real question isn’t “how do I authenticate this tool.” It’s “what does the system on the other end need to know about who’s asking.”</p><h3>Four answers, and how to pick</h3><p>Foundry gives you several authentication models for MCP tools, and they’re genuinely different workloads rather than better and worse versions of the same thing.</p><p>Model Downstream sees User context? Use when API key / shared token Shared credential No Everyone gets the same access Project managed identity The Foundry project No Several agents, same access level Agent identity That specific agent No Agents need different permissions OAuth passthrough The actual user Yes Access depends on who’s asking</p><p>One question sorts most of it: <strong>should every user of this agent see the same thing?</strong></p><p>Yes, and a shared identity is correct. It’s not a compromise, it’s the right design for a tool where access doesn’t vary by person.</p><p>No, and you need delegation. Nothing else will do, no matter how good the prompt is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z0CmhKnCSY18QqjsFVBQiQ.png" /><figcaption><em>Alice and Bob through the same agent. On shared identity paths they reach identical permissions. On OAuth passthrough they reach their own.</em></figcaption></figure><h3>Agent identity, and the trap that will get you</h3><p>Giving the agent its own Entra identity is the cleanest model to reason about. It’s a service account that belongs to the agent, and it’s exactly right for work with no human in it. A nightly job checking a storage container at 2am doesn’t need Alice. Nobody’s awake.</p><p>Here’s the part that will cost you an afternoon.</p><p>Before you publish, agents in the same Foundry project <strong>share</strong> an identity. After you publish, an agent gets its own.</p><p>So you develop, everything works, your role assignment is happily attached to the shared project identity. You publish. The agent now runs as a different principal, and storage returns 403 on code that worked ten minutes ago.</p><p>Nothing’s wrong with your code. Your permission is just bolted to an identity the published agent no longer uses.</p><p>This is why “the agent called the API successfully once” isn’t a security test. Test the published identity, not the one you developed against.</p><h3>Project identity is a boundary, not a shortcut</h3><p>You can also let agents use the Foundry project’s managed identity. Five internal agents that all need read access to the same storage account? Reasonable. One authorization path instead of five.</p><p>But be careful what you’re actually doing. If your finance agent needs payroll access and your marketing agent doesn’t, handing both a project identity that carries payroll permissions hasn’t simplified your security model. It’s just moved the problem somewhere it’s harder to see.</p><p>Shared access is convenient right up until it’s the thing in the incident report.</p><h3>OAuth passthrough, and what it does to your frontend</h3><p>When access genuinely depends on the person, Foundry’s OAuth identity passthrough preserves the user all the way to the tool. Same agent, same tool, different effective permissions.</p><p>The agent isn’t handed Alice’s password. The Agent Service manages the OAuth interaction: on first use it generates a consent link, Alice signs in and authorizes, and Foundry uses the resulting credentials for that agent talking to that MCP server.</p><p>Which means your application has to handle something a chat box doesn’t normally handle. Alice asks for her orders, the model reaches for the tool, and instead of tool output you get back an oauth_consent_request containing a consent_link.</p><p>That’s not an error. That’s the flow working. But your frontend now needs to understand agent events and surface that link, and if you only planned for text in and text out, you’ll be rebuilding it.</p><p>Two details worth knowing before you spend a day on either.</p><p><strong>Scopes are separated by spaces, not commas.</strong> Straight from the OAuth spec, and easy to get wrong:</p><pre>scope.one scope.two offline_access</pre><p>Include offline_access if you want refresh tokens, otherwise your users re-authorize every time the access token expires.</p><p><strong>A valid token can still be rejected.</strong> Foundry won’t forward a Microsoft token intended for a known Microsoft audience to an untrusted third-party MCP endpoint. You’ll see something like <em>cannot pass Microsoft token to untrusted MCP endpoint</em>, and the token is fine. The audience just isn’t meant for that destination. For a custom MCP server, use an audience you control with your own app registration.</p><p>When you debug OAuth, “is the token valid” is only the first question. Who issued it, who is it for, and is Foundry allowed to pass it there.</p><h3>Authentication isn’t the last gate</h3><p>Identity asks who you are. Authorization asks what you can reach. There’s a third question neither one answers: should this actually happen?</p><p>Say your MCP server exposes three tools.</p><pre>search_orders   read<br>get_order       read<br>cancel_order    changes the world</pre><p>I’d let the first two run automatically. The third is different in kind, not degree. A model can understand your instructions perfectly and still make a bad judgement call about whether to invoke it.</p><p>Foundry’s require_approval setting handles this, and it defaults to always if you don&#39;t set it. You can require approval for everything, disable it, or scope it to specific tool names.</p><p>The principle underneath: <strong>reading and changing state shouldn’t share an approval policy.</strong> If a tool can cancel, delete, send, or pay, put a human in front of it.</p><h3>Once you have five tools, wire them centrally</h3><p>Every agent managing its own connection to every tool gets ugly fast. Three agents and five tools is fifteen credential configurations, scattered, each one a place identity decisions can quietly diverge.</p><p>Toolboxes exist for this. Curate tools into a reusable bundle, configure authentication centrally, expose the whole thing through one MCP-compatible endpoint. Agents connect to the toolbox instead of wiring each tool individually, and identity decisions live in one place you can actually review.</p><p>That last part is the real benefit. Not fewer keystrokes. Fewer places for the security model to drift.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LPWMa0Dbyjk8o_9Gtj1vww.png" /><figcaption><em>A Foundry agent reaching multiple tools through a Toolbox, with identity, authorization and approval as three separate gates.</em></figcaption></figure><h3>When agents call agents</h3><p>Multi-agent makes the question sharper. A customer agent asks an orders agent to fetch Alice’s open orders. Who is the orders agent acting as?</p><p>Foundry’s A2A model draws the same shared-versus-individual line. A scheduler triggering a background chain can run on an agent identity the whole way down. A chain that started with Alice, where the answer depends on Alice’s permissions, has to carry Alice’s delegated identity through every hop.</p><p>The second one is more work. It’s also the only correct answer when the data is user-scoped, and there’s no prompt clever enough to substitute for it.</p><p>One trap if you’re building a middle tier. If your own API authenticates users and then delegates the end-user identity into a hosted agent, you can scope the session with the x-ms-user-identity header. But the calling identity needs a specific data action:</p><pre>Microsoft.CognitiveServices/accounts/AIServices/agents/endpoints/<br>UserIdentityImpersonation/action</pre><p>That permission isn’t in any built-in role. You need a custom role for the trusted middle tier. So if your architecture is browser to your API to hosted agent, your existing Foundry role assignments almost certainly aren’t enough.</p><h3>The test that actually tests something</h3><p>Two users. Alice can see orders 1001 and 1002. Bob can see 2001 and 2002.</p><p>Ask the same agent the same questions and check all four combinations. Alice asking for 1001 should work. Bob asking for 1001 should be denied. Then flip it.</p><p>If Bob can read Alice’s order, your identity isn’t reaching the API, no matter how correct the configuration screen looks.</p><p>Then a third test that’s easy to skip. Alice asks to <em>cancel</em> order 1001. She’s allowed to see it. Should the cancellation just happen? That’s your approval policy, and it’s a separate question from whether she’s authorized.</p><p>Three things being tested, not one. Identity: is this request Alice’s. Authorization: can Alice reach 1001. Approval: should this action run at all.</p><p>Most teams test the first and assume the other two.</p><h3>The four questions</h3><p>Where I’ve landed, and it’s mostly about what the model is and isn’t allowed to be responsible for.</p><p><strong>What does the model want to do?</strong> That’s reasoning. The model owns it.</p><p><strong>Who’s making the request?</strong> Identity. Not the model’s job.</p><p><strong>What can that identity reach?</strong> Authorization. Not the model’s job.</p><p><strong>Should this happen right now?</strong> Approval. Definitely not the model’s job.</p><p>The model helps with exactly one of those four, and the failure mode in most agent architectures is quietly letting it arbitrate the other three.</p><p>Which matters more every month, because we’ve moved past agents that answer “what was Q2 revenue.” These things search private repos, update records, call internal APIs, invoke other agents. Once an agent can <em>act</em>, identity stops being plumbing and becomes part of the architecture.</p><p>So next time you connect an agent to an MCP server, don’t start with how to authenticate it.</p><p>Start here: if this agent were a person on your team, who exactly would you want it to be, and what would you not give it the keys to?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d31c69d0716" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>