A technical walkthrough of the GA and public preview updates across Managed Connectors, Flex Consumption, Durable Task Scheduler, agentic workflows, language runtimes, and developer tooling.
At Microsoft Ignite 2026, we’re announcing a significant set of updates across Azure Functions and Durable Task Framework. The releases cover everything from new integration capabilities and custom containers on Flex Consumption to durable execution for AI applications, enterprise security and resilience, new language runtimes, and improvements to the tools developers use to build, deploy, and troubleshoot their applications. This post brings those announcements together, with a summary followed by a technical breakdown of each update.
At a glance: Microsoft Ignite 2026 announcements
| Area | What's new | Status | Learn more |
|---|---|---|---|
| Managed Connectors | Managed Connectors in Azure Functions (ConnectorTrigger with webhook + outbound polling modes, and outbound SDK) | GA | Blog · Docs · Samples |
| Flex Consumption containers and deployment | Custom Linux containers for OS-level dependencies, plus deployment validation logging in audit mode | Public Preview* | Blog · Docs · Samples |
| Durable Task SDKs & Durable Task Scheduler | GA: Durable Extension for Microsoft Agent Framework, Customer-managed keys (CMK), Private endpoints Preview*: Durable execution for LangGraph & Pydantic AI, Native disaster recovery, Task Queues, Durable Task SDK for Go | GA & Public Preview* | DTS Ignite blog · Agent Framework blog · Go SDK |
| Agentic functions & AI authoring | Azure Functions Hosted Skill and agent bindings (Python), Dynamic Workflows updates, and Azure Functions Canvas and Skills | Public Preview* | Hosted Skills · Agent bindings · Dynamic Workflows · Canvas · Skills docs |
| Language runtimes & workers | GA: Golang on Flex Consumption, .NET 11 Preview*: Python 3.15 (Rust worker transport), Node.js 26 | GA & Public Preview* | Go docs · .NET 11 blog · Python 3.15 blog · Runtimes matrix |
| Developer CLI & diagnostics | Azure Functions CLI (v5) and Azure Functions Network Troubleshooter v2 | Public Preview* | CLI docs · CLI repo · Network Troubleshooter blog |
Trigger functions from SaaS events and call enterprise APIs with Managed Connectors
Managed Connectors in Azure Functions (GA)
Managed Connectors in Azure Functions is now generally available together with Azure Connector Namespace (also GA), supporting .NET isolated, Python, and Node.js.
Triggering functions from SaaS events or calling systems such as SharePoint, Outlook, Teams, GitHub, Jira, or ServiceNow previously required custom OAuth token refresh code, webhook registration, and public inbound callback endpoints. A Connector Namespace manages your authorized connections, token refresh, and throttling while integrating with the Connector Trigger in a function app for inbound events. The Azure Connectors SDK (Azure.Connectors.Sdk, azure-connectors>=1.0.0, and @azure/connectors) can also be used for outbound actions across .NET isolated, Python, and Node.js.
Figure 1: Managed Connectors event delivery modes. Webhook mode pushes low-latency events over HTTPS, while the new polling mode pulls queued events outbound using a managed identity.
Webhook and Polling modes: Two event delivery modes are now supported between the Connector Namespace and the function app. Webhook mode pushes low-latency events from the Connector Namespace to the function app, validated by Entra ID or system keys. Polling mode (new at GA) has the function app pull queued events from the Connector Namespace over outbound HTTPS using a system-assigned or user-assigned managed identity, removing the need for a public callback endpoint and scaling on pending events (defaultTargetPendingEventThreshold: 16, maxPollingInterval: "00:00:30" in host.json).
@app.connector_trigger(
arg_name="emails",
connection="ConnectorNamespace",
delivery_mode=func.DeliveryMode.POLL,
trigger_config_name="%OnNewEmailTriggerConfigName%",
)
def on_new_email(emails: list[office365.GraphClientReceiveMessage]) -> None:
"""Triggered when a new email arrives in Office 365."""
logging.info("Received OnNewEmail trigger (%d items)", len(emails))
Get started: Read the Managed Connectors GA blog post and Polling triggers in Connector Namespace, review the Managed Connectors overview, and deploy a working .NET, Python, or Node.js sample from the functions-connectors samples repository.
Support for containers and deployment validation on Azure Functions Flex Consumption
OS-level dependency support via containers for Azure Functions Flex Consumption (Public Preview*)
We now support custom containers on Azure Functions Flex Consumption. Previously, needing OS-level packages such as headless Chromium for HTML-to-PDF rendering, GnuPG for payload encryption, custom fonts, or native dependencies meant moving off Flex Consumption to a full custom-container plan where you also had to patch the Functions host.
With Flex Consumption's worker-only container model, you package your app, one language worker (.NET 10/11 isolated, Python 3.13–3.15, Node.js 24, or Go 1.27), and any OS binaries inside a Linux container image while Azure operates and patches the Functions host, trigger listeners, and scaler outside your container.
Figure 2: Responsibility split in the Flex Consumption worker-only container model. Azure manages the host and scaler while your image supplies the language worker, code, and OS packages.
Pull images from Azure Container Registry, Docker Hub, or private registries via SystemAssignedIdentity, UserAssignedIdentity, Basic credentials, or Anonymous access using immutable SHA256:<digest> references:
az functionapp create \
--resource-group <rg> --name <app> --storage-account <storage> \
--flexconsumption-location <region> --runtime <dotnet-isolated|python|node|go> \
--runtime-version <ver> --deployment-image <registry>/<repo>@sha256:<digest> \
--deployment-image-auth-type SystemAssignedIdentity
Get started: Read the Flex Consumption container blog post and OS-level dependencies documentation, or deploy a ready-to-run sample repository for .NET isolated, Python, Go, or Node.js.
Deployment validation logging in audit mode on Flex Consumption
Flex Consumption also introduces improved deployment logging with pre-production deployment validation in audit mode (enabled by default). On every code deployment, the platform spins up an isolated validation worker to verify that your package starts cleanly and registers valid triggers, logging a summary of discovered functions (name, language, and binding types/directions) to Kudu deployment logs and Application Insights traces. If a package fails to initialize or produce valid triggers, the deployment still proceeds via the standard deployment path without blocking—while emitting an actionable warning in the deployment log with the failure reason, deployment ID, and troubleshooting guidance so you can catch broken packages at deploy time rather than discovering silent failures later in production.
Stateful orchestrations and enterprise controls in Durable Task Scheduler
Durable Task Scheduler (DTS) is the managed backend for Durable Functions, Durable Task SDK workers, and stateful agents. At Ignite 2026, updates expand DTS across enterprise security, regional resilience, rate control, Go orchestration authoring, and durable agent execution.
Figure 3: Enterprise topology for Durable Task Scheduler combining VNet private endpoints, customer-managed keys in Key Vault or Managed HSM, task queues, and active-passive regional disaster recovery.
Here is the full list of durable updates:
- Durable agents — Durable Extension for Microsoft Agent Framework (GA), LangGraph (Public Preview*), and Pydantic AI: The Durable Extension for Microsoft Agent Framework is generally available for .NET (
Microsoft.Agents.AI.Hosting.AzureFunctions) and Python (agent-framework-azurefunctions), persisting agent conversation state, deterministicWorkflowBuildergraphs, parallel multi-agent fan-out, and zero-computeWaitForExternalEventhuman approvals in a task hub with token monitoring in the DTS dashboard (GA blog · Azure Functions hosting). Beyond Microsoft Agent Framework, durable execution with DTS for LangGraph is in public preview*, and Pydantic AI now includes Azure Durable Task as a built-in durability option. - Customer-managed keys (GA): Encrypts task hub orchestration history, entity state, and payloads at rest on the Dedicated SKU using keys in Azure Key Vault or Managed HSM via a user-assigned managed identity (docs).
- Private endpoints (GA): Connects VNet-integrated Function Apps and workers to DTS over Azure Private Link with public network access disabled on Consumption and Dedicated SKUs (docs).
- Native disaster recovery (Public Preview*): Replicates task hub state across paired primary and secondary regions for unplanned failover and zero-drain planned failover (docs).
- Task Queues (Public Preview*): Caps the sustained dispatch rate on a named queue via the
DTS_TaskQueuetag so background bursts cannot starve latency-sensitive workflows or overload downstream APIs (docs). - Durable Task SDK for Go (Public Preview*): Brings code-first orchestrations, activities, fan-out/fan-in, external events, durable timers, and retry policies to Go 1.25+ (
microsoft/durabletask-go), poweringmiddleware/durabletaskin the Azure Functions Go worker.
Get started: Read the Durable Task Scheduler Ignite 2026 blog post for deep dives, limits, and setup steps across these updates.
Agentic functions, bindings, and AI-assisted development
These announcements cover both sides of building with AI on Azure Functions: invoking skills and agents from Python functions at runtime, and using AI coding assistants to scaffold, modernize, test, and deploy function apps across languages.
Azure Functions Hosted Skill and agent bindings (Public Preview*)
If you have a function that processes orders, handles queue messages, or responds to HTTP requests and need AI reasoning for part of the job, Hosted Skill and agent bindings let you add a skill or agent to classify an incoming request, assess risk, summarize a document, or decide what action to take next without writing the setup and lifecycle code yourself. Your function stays in control of input validation, when the agent runs, error handling, and what happens with the result, keeping predictable business logic in your function without moving your entire application into an agent framework.
Hosted Skill and agent bindings are available in public preview for Python (3.13+ on Flex Consumption, Elastic Premium, and Dedicated). There are two binding types, with a choice of SDK for agent bindings:
- Hosted Skill Binding (
app.hosted_skill): Brings the Hosted Skills programming model (azurefunctions-agents-runtime) into your function. Invoke a Markdown-defined skill (agents/<name>.agent.md), run skills (skill.run()), stream results (skill.stream()), and continue conversations viasession_idwhile reusing its configuration, tools, and conversation history. Choose this binding when you want to add agentic logic through a skill-oriented API rather than work with SDK-specific agent and session APIs. - Agent bindings (
app.markdown_agent): Provide a configured, native Microsoft Agent Framework (MAF) agent (azurefunctions-agents-extensions-agent-framework) or a native GitHub Copilot SDK session (azurefunctions-agents-extensions-copilot-sdk) directly to your function. The binding handles agent or session setup and lifecycle management. With MAF, you can use its SDK APIs, supply your own model client, add custom Python tools, and use replay-safecontext.call_agent()in Durable orchestrations. With the GitHub Copilot SDK, you can use its session APIs, tools, and configuration options. Choose an agent binding when you want direct access to either SDK with less setup code. - Dynamic Workflows: Hosted Skills Dynamic Workflows now supports async operations with the
workflowtool, retry policies, and Continue on Error, enabling a wider range of use cases.
Figure 4: Azure Functions Hosted Skill and agent bindings for Python. Your function owns triggers, validation, branching, and error handling while the binding manages setup and lifecycle for Hosted Skills, Microsoft Agent Framework, or the GitHub Copilot SDK.
app = HostedSkillFunctionApp()
@app.route(route="summarize", methods=["POST"])
@app.hosted_skill(arg_name="skill", agent_name="summarizer")
async def summarize(req: func.HttpRequest, skill: HostedSkill) -> func.HttpResponse:
result = await skill.run(req.get_body().decode("utf-8"))
return func.HttpResponse(result.content, status_code=200)
Get started: Read the Hosted Skills documentation, Hosted Skill binding guide, agent bindings documentation, and Dynamic Workflows blog post, or deploy a starter app with azd up using Azure-Samples/functions-quickstart-serverless-agents-azd.
Azure Functions Canvas and Azure Functions Skills (Public Preview*)
Azure Functions Canvas is built for developers using the GitHub Copilot app and VS Code, with an early release available now as part of Awesome Copilot (Azure Functions | Awesome GitHub Copilot). It provides an interactive workspace to build and manage Azure Functions apps with AI coding tools:
- Template system built for AI coding: Go from create to build, local test, and deploy while using fewer tokens and waiting less. Previously, using an official template alongside an AI coding tool required opening Visual Studio or VS Code; you can now complete the entire workflow without leaving the GitHub Copilot app.
- Modernize: Identifies runtime versions, language versions, and hosting SKUs that are out of support or approaching end of support, then helps migrate your project to the latest versions and programming models.
- Localized UI: The Canvas panel is available in 7 languages.
Figure 5: Azure Functions Canvas in the GitHub Copilot app, bringing template-based creation, local testing, modernization checks, and monitoring into a single workspace.
Azure Functions Skills adds updates for coding agents:
- Upgraded
azure-functions-hosted-skillsskill: Builds Hosted Skills from start to finish using prompts, now adding Dynamic Workflows support and finer control over Managed Connectors (Quickstart: Create an Azure Functions hosted skill with an AI coding assistant). - New
azure-functions-hosted-skills-migrateskill: Converts existing local skills or local coding-agent automations on your machine into Azure Functions Hosted Skills (Migrate local agent workflows to Azure Functions hosted skills). - Go support: Azure Functions Skills now supports Go development.
copilot plugin install azure-functions@awesome-copilot
Get started: Install the Azure Functions Canvas extension on Awesome GitHub Copilot and read Azure Functions skills for coding agents.
Language runtime updates: Go, .NET 11, Python 3.15, and Node.js 26
These runtime updates include the general availability of Go support on Azure Functions and day-zero GA support for .NET 11, alongside public previews for Python 3.15 with a Rust-based worker transport and Node.js 26.
| Language | Version | Status | Supported hosting plans | Notable architecture change |
|---|---|---|---|---|
| Go | Go 1.24+ | GA | Flex Consumption | Native gRPC worker (azure-functions-golang-worker) replaces HTTP custom handlers |
| .NET | .NET 11 STS (.NET isolated model) | GA | All active Azure Functions hosting plans | Azure.Functions.Sdk MSBuild SDK and rootless chiseled base images |
| Python | Python 3.15 | Public Preview* | Flex Consumption, Elastic Premium, Dedicated (Linux) | Rust-based worker transport embeds CPython, removing worker grpcio/protobuf conflicts |
| Node.js | Node.js 26 | Public Preview* | Flex Consumption, Elastic Premium, Dedicated (Linux) | Early runtime and npm compatibility validation on the v4 programming model |
Golang support on Azure Functions Flex Consumption (GA)
Go support on Azure Functions is now generally available on Flex Consumption with Go 1.24+. Powered by the open-source Azure Functions Go worker, Go functions communicate directly with the Functions host over gRPC and support standard net/http handlers (including http.Flusher response streaming), typed triggers across Azure event sources, Azure SDK input bindings, Durable Functions orchestrations via middleware/durabletask, structured logging with log/slog, and OpenTelemetry.
func main() {
app := sdk.FunctionApp()
app.HTTP("hello", helloHandler).Methods("GET", "POST").AuthLevel(http.AuthLevelFunction)
worker.Start(app)
}
Get started: Read the Go developer guide and Go quickstart, or deploy a sample app from azure-functions-golang-worker/samples.
Azure Functions support for .NET 11 (GA)
Azure Functions now supports .NET 11 at GA in the .NET isolated model across all active Azure Functions hosting plans. Projects use the new Azure.Functions.Sdk MSBuild SDK for simpler project files without a separate Worker SDK package reference, and containerized deployments gain smaller, rootless Ubuntu chiseled base images. Read the .NET 11 GA blog post and .NET isolated guide.
Python 3.15 and Node.js 26 (Public Preview*)
Azure Functions now supports Python 3.15 and Node.js 26 in public preview* across Flex Consumption, Elastic Premium, and Dedicated plans on Linux:
- Python 3.15: Introduces a Rust-based worker transport that embeds CPython and handles host-to-worker gRPC communication outside your Python environment, eliminating
grpcioandprotobufversion conflicts with application and AI SDK dependencies. Read A Rust foundation for Python: evolving the Azure Functions worker and see the Python supported languages matrix. - Node.js 26: Lets teams validate
azure/functionsv4 apps and npm dependencies in JavaScript and TypeScript ahead of LTS migration. See the Node.js supported languages matrix.
Azure Functions CLI (v5) and Network Troubleshooter v2
Azure Functions CLI (v5) (Public Preview*)
The Azure Functions CLI (v5) is now in public preview* as the next major version of the local development runtime and tooling for Azure Functions:
- Workloads: Instead of shipping a single monolithic binary that bundles every language runtime, the v5 CLI uses a small language-agnostic base install and downloads workloads on demand for your stack—including the Functions host, extension bundles, language workers, project tooling, and templates. Because the host and workers ship as independent workloads, updates to the Functions host and language workers can also roll out faster without re-downloading the entire CLI.
- SKU-targeted profiles: Profiles align your local environment with the Azure hosting plan you are targeting, such as Flex Consumption, by pinning the host, extension bundle, and worker versions to match that SKU. Previously, Core Tools v4 had to wait until a capability was available across all hosting SKUs before the CLI could adopt it; separating SKU profiles in v5 ensures that what you build locally is compatible with your target SKU and lets us ship new platform, host, and worker updates to plans like Flex Consumption much faster.
Read the CLI local development guide or file issues in azure/azure-functions-cli.
iex "& { $(irm https://aka.ms/func-cli/install.ps1) } -Prerelease"
func setup --features python
func run --profile <profile-name>
Azure Functions Network Troubleshooter v2 (Public Preview*)
Diagnosing why a VNet-integrated Function App fails to reach backing resources previously required cross-checking multiple portal blades or running Kudu CLI probes, which do not exist on Flex Consumption. Available in the Azure portal under Diagnose and solve problems > Network Troubleshooter, v2 renders a top-down dependency graph across Storage, Service Bus, Key Vault, Azure Files, and monitoring endpoints, surfacing failing checks first with remediation guidance. On Dedicated, Elastic Premium, and Windows Consumption, it runs live connectivity, DNS, TCP, firewall, and RBAC checks; on Flex Consumption, it performs static ARM and control-plane validation across app VNet/DNS settings, destination firewalls/private endpoints/NSGs/Private DNS zone links, and Managed Identity RBAC roles. Read the Network Troubleshooter blog post.
Figure 6: Azure Functions Network Troubleshooter (preview) in the Azure portal discovering function bindings, Storage accounts, and Service Bus namespaces and validating connectivity and network settings.
Companion blog posts and engineering deep dives
If you made it this far and want more, we got you! Our PMs and engineers published companion announcement and architecture deep-dive posts across these releases:
- Managed Connectors and integrations
- Platform architecture and Flex Consumption
- Durable Task Scheduler, SDKs, and agentic workflows
- What's new in Azure Functions Durable Task Scheduler at Microsoft Ignite 2026
- Durable Task Extension for Microsoft Agent Framework is now Generally Available
- Introducing Azure Durable Task for Pydantic AI agents
- Task queues in Durable Task Scheduler
- Enable Dynamic Workflows in Azure Functions Hosted Skills
- Language runtimes and diagnostics
See us at Microsoft Ignite 2026 and get started
Join our engineering and product teams at Microsoft Ignite next week or watch on demand:
- BRK423: Build AI-native with Azure's agentic application platform, covering what is new across Azure's agentic application platform services, including Azure Functions.
- LTG1294: Build event-driven AI apps with Azure Functions, a lightning talk by Madhura Bharadwaj on the Azure Functions PM team covering Azure Functions Hosted Skills.
We look forward to your feedback and using these new features.
*Preview features are provided for evaluation and testing, are not recommended for production workloads, and are subject to the Supplemental Terms of Use for Microsoft Azure Previews.