Azure Functions is redefining event-driven applications and high-scale APIs in 2025, accelerating innovation for developers building the next generation of intelligent, resilient, and scalable workloads. This year, our focus has been on empowering AI and agentic scenarios: remote MCP server hosting, bulletproofing agents with Durable Functions, and first-class support for critical technologies like OpenTelemetry, .NET 10 and Aspire. With major advances in serverless Flex Consumption, enhanced performance, security, and deployment fundamentals across Elastic Premium and Flex, Azure Functions is the platform of choice for building modern, enterprise-grade solutions.

Remote MCP

Model Context Protocol (MCP) has taken the world by storm, offering an agent a mechanism to discover and work deeply with the capabilities and context of tools.  When you want to expose MCP/tools to your enterprise or the world securely, we recommend you think deeply about building remote MCP servers that are designed to run securely at scale.  Azure Functions is uniquely optimized to run your MCP servers at scale, offering serverless and highly scalable features of Flex Consumption plan, plus two flexible programming model options discussed below.  All come together using the hardened Functions service plus new authentication modes for Entra and OAuth using Built-in authentication.

Remote MCP Triggers and Bindings Extension GA

Back in April, we shared a new extension that allows you to author MCP servers using functions with the MCP tool trigger.  That MCP extension is now generally available, with support for C#(.NET), Java, JavaScript (Node.js), Python, and Typescript (Node.js). The MCP tool trigger allows you to focus on what matters most: the logic of the tool you want to expose to agents. Functions will take care of all the protocol and server logistics, with the ability to scale out to support as many sessions as you want to throw at it.

    [Function(nameof(GetSnippet))]
    public object GetSnippet(
        [McpToolTrigger(GetSnippetToolName, GetSnippetToolDescription)]
            ToolInvocationContext context,
        [BlobInput(BlobPath)] string snippetContent
    )
    {
        return snippetContent;
    }

 

New: Self-hosted MCP Server (Preview)

If you’ve built servers with official MCP SDKs and want to run them as remote cloud‑scale servers without re‑writing any code, this public preview is for you. You can now self‑host your MCP server on Azure Functions—keep your existing Python, TypeScript, .NET, or Java code and get rapid 0 to N scaling, built-in server authentication and authorization, consumption-based billing, and more from the underlying Azure Functions service.

This feature complements the Azure Functions MCP extension for building MCP servers using the Functions programming model (triggers & bindings). Pick the path that fits your scenario—build with the extension or standard MCP SDKs. Either way you benefit from the same scalable, secure, and serverless platform.

Use the official MCP SDKs:

# MCP.tool()
async def get_alerts(state: str) -> str:
    """Get weather alerts for a US state.

    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Unable to fetch alerts or no alerts found."

    if not data["features"]:
        return "No active alerts for this state."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\n---\n".join(alerts)

Use Azure Functions Flex Consumption Plan's serverless compute using Custom Handlers in host.json:

{
   "version": "2.0",
    "configurationProfile": "mcp-custom-handler",
    "customHandler": {
        "description": {
            "defaultExecutablePath": "python",
            "arguments": ["weather.py"] 
        },
        "http": {
            "DefaultAuthorizationLevel": "anonymous"
        },
        "port": "8000"
    }
}

Learn more about MCPTrigger and self-hosted MCP servers at https://aka.ms/remote-mcp

Built-in MCP server authorization (Preview)

The built-in authentication and authorization feature can now be used for MCP server authorization, using a new preview option. You can quickly define identity-based access control for your MCP servers with Microsoft Entra ID or other OpenID Connect providers. Learn more at https://aka.ms/functions-mcp-server-authorization.

 

Better together with Foundry agents

Microsoft Foundry is the starting point for building intelligent agents, and Azure Functions is the natural next step for extending those agents with remote MCP tools. Running your tools on Functions gives you clean separation of concerns, reuse across multiple agents, and strong security isolation. And with built-in authorization, Functions enables enterprise-ready authentication patterns, from calling downstream services with the agent’s identity to operating on behalf of end users with their delegated permissions.

Build your first remote MCP server and connect it to your Foundry agent at https://aka.ms/foundry-functions-mcp-tutorial.

Agents

Microsoft Agent Framework 2.0 (Public Preview Refresh)

We’re excited about the preview refresh 2.0 release of Microsoft Agent Framework that builds on battle hardened work from Semantic Kernel and AutoGen.  Agent Framework is an outstanding solution for building multi-agent orchestrations that are both simple and powerful.  Azure Functions is a strong fit to host Agent Framework with the service’s extreme scale, serverless billing, and enterprise grade features like VNET networking and built-in auth.  

Durable Task Extension for Microsoft Agent Framework (Preview)

The durable task extension for Microsoft Agent Framework transforms how you build production-ready, resilient and scalable AI agents by bringing the proven durable execution (survives crashes and restarts) and distributed execution (runs across multiple instances) capabilities of Azure Durable Functions directly into the Microsoft Agent Framework. Combined with Azure Functions for hosting and event-driven execution, you can now deploy stateful, resilient AI agents that automatically handle session management, failure recovery, and scaling, freeing you to focus entirely on your agent logic.

 

Key features of the durable task extension include:

• Serverless Hosting: Deploy agents on Azure Functions with auto-scaling from thousands of instances to zero, while retaining full control in a serverless architecture.
• Automatic Session Management: Agents maintain persistent sessions with full conversation context that survives process crashes, restarts, and distributed execution across instances
• Deterministic Multi-Agent Orchestrations: Coordinate specialized durable agents with predictable, repeatable, code-driven execution patterns
• Human-in-the-Loop with Serverless Cost Savings: Pause for human input without consuming compute resources or incurring costs
• Built-in Observability with Durable Task Scheduler: Deep visibility into agent operations and orchestrations through the Durable Task Scheduler UI dashboard

Create a durable agent: 

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o-mini")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    credential=AzureCliCredential()
).create_agent(
    instructions="""You are a professional content writer who creates engaging, 
    well-structured documents for any given topic. 
    
    When given a topic, you will:
    1. Research the topic using the web search tool
    2. Generate an outline for the document
    3. Write a compelling document with proper formatting
    4. Include relevant examples and citations""",
    name="DocumentPublisher",
    tools=[
        AIFunctionFactory.Create(search_web),
        AIFunctionFactory.Create(generate_outline)
    ]
)

# Configure the function app to host the agent with durable session management
app = AgentFunctionApp(agents=[agent])

app.run()

 

Durable Task Scheduler dashboard for agent and agent workflow observability and debugging

 

For more information on the durable task extension for Agent Framework, see the announcement: https://aka.ms/durable-extension-for-af-blog.

Flex Consumption Updates

 

As you know, Flex Consumption means serverless without compromise. It combines elastic scale and pay‑for‑what‑you‑use pricing with the controls you expect: per‑instance concurrency, longer executions, VNet/private networking, and Always Ready instances to minimize cold starts.

Since launching GA at Ignite 2024 last year, Flex Consumption has had tremendous growth with over 1.5 billion function executions per day and nearly 40 thousand apps.

Here’s what’s new for Ignite 2025:

• 512 MB instance size (GA). Right‑size lighter workloads, scale farther within default quota.
• Availability Zones (GA). Distribute instances across zones.
• Rolling updates (Public Preview). Unlock zero-downtime deployments of code or config by setting a single configuration. See below for more information.
• Even more improvements including: new diagnostic settingsto route logs/metrics, use Key Vault App Config references,  new regions, and Custom Handler support.

To get started, review Flex Consumption samples, or dive into the documentation to see how Flex can support your workloads.

Migrating to Azure Functions Flex Consumption

Migrating to Flex Consumption is simple with our step-by-step guides and agentic tools. Move your Azure Functions apps or AWS Lambda workloads, update your code and configuration, and take advantage of new automation tools. With Linux Consumption retiring, now is the time to switch.

For more information, see:

• Migrate Consumption plan apps to the Flex Consumption plan
• Migrate AWS Lambda workloads to Azure Functions

Durable Functions

 

Durable Functions introduces powerful new features to help you build resilient, production-ready workflows:

• Distributed Tracing: lets you track requests across components and systems, giving you deep visibility into orchestration and activities with support for App Insights and OpenTelemetry.
• Extended Sessions support in .NET isolated: improves performance by caching orchestrations in memory, ideal for fast sequential activities and large fan-out/fan-in patterns.
• Orchestration versioning (public preview): enables zero-downtime deployments and backward compatibility, so you can safely roll out changes without disrupting in-flight workflows

Durable Task Scheduler Updates

Durable Task Scheduler Dedicated SKU (GA):
Now generally available, the Dedicated SKU offers advanced orchestration for complex workflows and intelligent apps. It provides predictable pricing for steady workloads, automatic checkpointing, state protection, and advanced monitoring for resilient, reliable execution. 

Durable Task Scheduler Consumption SKU (Public Preview):
The new Consumption SKU brings serverless, pay-as-you-go orchestration to dynamic and variable workloads. It delivers the same orchestration capabilities with flexible billing, making it easy to scale intelligent applications as needed. 

For more information see: https://aka.ms/dts-ga-blog

OpenTelemetry support in GA

Azure Functions OpenTelemetry is now generally available, bringing unified, production-ready observability to serverless applications. Developers can now export logs, traces, and metrics using open standards—enabling consistent monitoring and troubleshooting across every workload.

Key capabilities include:

• Unified observability: Standardize logs, traces, and metrics across all your serverless workloads for consistent monitoring and troubleshooting.
• Vendor-neutral telemetry: Integrate seamlessly with Azure Monitor or any OpenTelemetry-compliant backend, ensuring flexibility and choice.
• Broad language support: Works with .NET (isolated), Java, JavaScript, Python, PowerShell, and TypeScript.

Start using OpenTelemetry in Azure Functions today to unlock standards-based observability for your apps. For step-by-step guidance on enabling OpenTelemetry and configuring exporters for your preferred backend, see the documentation.

Deployment with Rolling Updates (Preview)

Achieving zero-downtime deployments has never been easier. The Flex Consumption plan now offers rolling updates as a site update strategy. Set a single property, and all future code deployments and configuration changes will be released with zero-downtime.

Instead of restarting all instances at once, the platform now drains existing instances in batches while scaling out the latest version to match real-time demand. This ensures uninterrupted in-flight executions and resilient throughput across your HTTP, non-HTTP, and Durable workloads – even during intensive scale-out scenarios.

Rolling updates are now in public preview. Learn more at https://aka.ms/functions/rolling-updates.

Secure Identity and Networking Everywhere By Design

Security and trust are paramount. Azure Functions incorporates proven best practices by design, with full support for managed identity—eliminating secrets and simplifying secure authentication and authorization. Flex Consumption and other plans offer enterprise-grade networking features like VNETs, private endpoints, and NAT gateways for deep protection. The Azure Portal streamlines secure function creation, and updated scenarios and samples showcase these identity and networking capabilities in action. Built-in authentication (discussed above) enables inbound client traffic to use identity as well.  Check out our updated Functions Scenarios page with quickstarts or our secure samples gallery to see these identity and networking best practices in action. 

 

.NET 10

Azure Functions now supports .NET 10, bringing in a great suite of new features and performance benefits for your code. .NET 10 is supported on the isolated worker model, and it’s available for all plan types except Linux Consumption.

As a reminder, support ends for the legacy in-process model on November 10, 2026, and the in-process model is not being updated with .NET 10. To stay supported and take advantage of the latest features, migrate to the isolated worker model.

Aspire

Aspire is an opinionated stack that simplifies development of distributed applications in the cloud. The Azure Functions integration for Aspire enables you to develop, debug, and orchestrate an Azure Functions .NET project as part of an Aspire solution.  Aspire publish directly deploys to your functions to Azure Functions on Azure Container Apps. 

Aspire 13 includes an updated preview version of the Functions integration that acts as a release candidate with go-live support. The package will be moved to GA quality with Aspire 13.1.

Java 25, Node.js 24

Azure Functions now supports Java 25 and Node.js 24 in preview. You can now develop functions using these versions locally and deploy them to Azure Functions plans.

Learn how to upgrade your apps to these versions here

 

In Summary

Ready to build what’s next? Update your Azure Functions Core Tools today and explore the latest samples and quickstarts to unlock new capabilities for your scenarios. The guided quickstarts run and deploy in under 5 minutes, and incorporate best practices—from architecture to security to deployment. We’ve made it easier than ever to scaffold, deploy, and scale real-world solutions with confidence.

The future of intelligent, scalable, and secure applications starts now—jump in and see what you can create!