Azure Functions Model Context Protocol Support Goes GA: A Win for Secure Agentic Workflows

TL;DR Microsoft has moved its Model Context Protocol (MCP) support for Azure Functions to General Availability, signaling a shift toward standardized, identity-secure agentic workflows. With built-in OBO authentication and streamable HTTP transport, it addresses key security concerns and now supports multiple languages while enabling self-hosting. This matters because it removes friction from connecting AI agents to enterprise systems—and your infrastructure bills stay reasonable.

Why This Matters Right Now

For years, the dirty secret of agentic AI was that connecting models to real enterprise tools felt like duct-taping a Ferrari to a shopping cart. MCP servers may have up to 50+ tools, and users were documenting setups with 7+ servers consuming 67k+ tokens. That context bloat meant slower inference, higher costs, and agents that couldn’t focus on the actual problem. By integrating native OBO authentication and streamable HTTP transport, the update aims to solve the ‘security pain point’ that has historically prevented AI agents from accessing sensitive downstream enterprise data. For .NET engineers on Azure, this is the moment when agentic workflows stop being a prototype concern and become a production reality.

What’s Actually New

Multi-Language Support & Self-Hosting The MCP extension now supports .NET, Java, JavaScript, Python, and TypeScript, while a new self-hosted option lets developers deploy existing MCP SDK-based servers without code changes. If you’re running .NET services in Azure Functions, you can now wrap them as MCP servers and let agents call them securely—no middleware gymnastics required.

Direct Azure AI Foundry Integration The platform integrates directly with Azure AI Foundry, allowing agents to discover and invoke MCP tools without additional configuration layers. This is the connective tissue that was missing. Instead of manually wiring up tool definitions and managing authentication separately, agents can discover and use your functions as first-class tools.

Quickstart Templates Microsoft has published quickstart templates for both hosting approaches across multiple languages, with C# (.NET), Python, TypeScript (Node.js) available, and a Java QuickStart coming soon. —

Practical Integration: A .NET Example

Here’s what a minimal MCP-enabled Azure Function looks like in C#:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

public static class OrderLookupFunction
{
    [Function("OrderLookup")]
    public static async Task<OrderInfo> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "orders/{id}")] 
        HttpRequestData req,
        string id,
        FunctionContext executionContext)
    {
        var logger = executionContext.GetLogger("OrderLookup");
        
        // Your existing business logic
        var order = await FetchOrderFromDatabase(id);
        
        logger.LogInformation($"Agent queried order {id}");
        return order;
    }
}

The MCP layer handles:

Authentication: OBO (On-Behalf-Of) flow automatically passes the caller’s identity
Tool Discovery: Agents see this function as a callable tool with schema
Streaming: Large responses don’t block the agent’s reasoning loop

No custom API gateways. No token-passing plumbing. The security model is built in.

The Cost & Latency Story

This matters for your bottom line. By removing the noise of hundreds of unused tools, the model can dedicate its “attention” mechanisms to the user’s actual query and the relevant active tools. In practice:

Fewer tokens consumed = lower API costs per inference
Faster agent reasoning = lower latency for user-facing workflows
Reduced hallucination = agents spend less context on irrelevant tool definitions

For a production agent making 10,000 calls/day, this can mean the difference between a $500/day bill and a $200/day bill.

Integration Checklist for Teams

Audit existing Azure Functions: Which ones could be agent tools? (Database queries, approval workflows, external API calls.)
Deploy the MCP quickstart: Use the C# template to wrap a function as an MCP server.
Register in Azure AI Foundry: Point your agents to the MCP endpoint; they’ll auto-discover tools.
Test with a simple agent: Start with read-only operations (lookups, searches) before write operations.
Monitor & iterate: Use Application Insights to track agent tool calls and latency.

The Broader Context

Anthropic’s Model Context Protocol proved the missing connective tissue and is quickly becoming the standard, with OpenAI and Microsoft publicly embracing MCP. With MCP reducing the friction of connecting agents to real systems, 2026 is likely to be the year agentic workflows finally move from demos into day-to-day practice. This GA release is Microsoft signaling: we’re betting on agentic systems as a core enterprise pattern. If you’re shipping on .NET and Azure, now’s the time to get familiar with MCP—not as a curiosity, but as infrastructure.