serverless
238 TopicsAzure Functions Canvas (Preview): Build, run, and modernize Function Apps with GitHub Copilot
If you use the GitHub Copilot app or Visual Studio Code, meet the Azure Functions canvas. More and more developers now build with coding agents. The Azure Functions canvas helps you get more from that workflow. It addresses three common problems in Azure Functions development: Use official templates without leaving your workflow. Get the same high-quality Azure Functions templates available in VS Code, directly in the GitHub Copilot app. Start building without switching tools. Agents get there eventually, but slowly. A coding agent can produce an app that runs, but it can take many turns. You also can't always tell whether the result follows best practices. Outdated choices cause incidents. Programming models, hosting plans, and runtime versions that reach end of support can cause outages. So can incorrect code or settings. Canvases are new in the GitHub Copilot app. A canvas runs deterministic tasks quickly, without a round trip through the agent. It also gives you a visual workspace with state that you and the agent share. We're only starting to explore what canvases make possible. Build faster with up-to-date templates The canvas includes 90 starter and scenario templates for Azure Functions and Hosted Skills. They're more than samples: many include Bicep templates that deploy with the Azure Developer CLI (azd). The canvas applies a template directly, so the agent needs fewer turns and less time to give you working code. This is real code in your local work tree. You own the code and can extend it with GitHub Copilot, add it to your repository, and deploy it to Azure. The canvas supports the full development loop: create, run locally, test, and deploy. You can also open your project in VS Code to continue development and debugging. Test your event-driven functions Azure Functions is built for event-driven applications, but testing different triggers isn't always straightforward. The Azure Functions canvas brings event-driven testing into your development workflow. It supports HTTP, Timer, Event Hubs, Service Bus, Storage Queue, Blob, Durable Functions, and Blob triggers with Event Grid. Instead of switching between tools, you can test your functions as you build them, making it easier to develop and validate event-driven applications. Build Hosted Skills with templates and an agent With Hosted Skills, you build event-driven agents in natural language. The canvas includes 14 templates for them. Start from the template that matches your scenario to scaffold quickly, then let the agent continue. Built-in skills help the agent with creation, deployment, and configuration. To build and test a Hosted Skill step by step, see Quickstart: Build and test a hosted skill with the Azure Functions hosted skills canvas. Modernize with confidence On PaaS and serverless platforms, you must regularly review programming models, hosting plans, and supported runtime versions. This is important for security and reliability. Internal data from the Azure Functions team shows that 58% of incidents come from code or configuration issues. These issues are easy to miss. With the canvas, you can quickly find them in local projects and in apps deployed to Azure, and then have the agent fix them. Checks are read-only, and fixes need your approval. The canvas helps you follow current Azure Functions security and runtime best practices, from choosing supported configurations to identifying issues in existing applications. Continue development in VS Code Your project is real code, not a prototype locked inside the canvas. Open it in VS Code to continue development with your familiar tools. The generated project includes configuration and infrastructure files to help you run locally and deploy to Azure. Available in seven languages From day one, the canvas supports seven languages: English, Chinese (Simplified), German, Japanese, Korean, Portuguese (Brazil), and Spanish. Get started Find Azure Functions on Awesome GitHub Copilot, or install it from the marketplace: in the GitHub Copilot app, open Customize > Plugins, select Awesome Copilot, and install Azure Functions. Pro tip: install it directly. Start a new session, then ask: Open Azure Functions canvas. Use it in VS Code (Preview). Canvases are available in VS Code 1.142 and later for local sessions that use the Copilot harness. Install the plugin in the GitHub Copilot app as shown above. Then, in VS Code, enable chat.canvases.enabled, start a new session with the Copilot harness, and ask the agent to open the Azure Functions canvas. For details, see Canvases (Preview). On Home, choose a task: Create, Open, Modernize, or Monitor. You don't need extra tools to open the canvas. To create from a template or deploy, install the Azure Developer CLI (azd). To run locally, install Azure Functions Core Tools 4. Check prerequisites in the canvas shows what you're missing. Give it a try, and tell us what you think.153Views0likes1CommentWhat’s new in Azure SRE Agent at Microsoft Ignite 2026
At Microsoft Ignite 2026, Azure SRE Agent joins Microsoft Teams as a member of your team, with its own Microsoft Entra agent identity. It also now collaborates with other teams’ agents, investigates across AWS and Google Cloud, and starts work from the Azure Container Apps portal, Azure CLI, Grafana, and connector triggers.308Views0likes0CommentsPublic preview: OS-level dependency support via containers for Azure Functions Flex Consumption
Your function needs Chromium to generate a PDF. Or GnuPG to encrypt data. Or a native Linux library that isn’t available in the managed execution environment. Until now, an OS-level dependency could require redesigning the application, moving part of the workload to another service, or selecting another hosting option. Today, we’re announcing the public preview of OS-level dependency support via containers on Azure Functions Flex Consumption. With this capability, you can build a Linux container image containing your function application, one supported Functions language worker, application dependencies, and the OS-level software your workload needs. Azure continues to operate the Functions host, trigger integration, routing, and Flex Consumption scaling outside your image. See it in action: Generate PDFs with .NET and Chromium Consider a function that converts HTML into a PDF by using .NET, Puppeteer Sharp, and Chromium. The application needs more than a NuGet package. Puppeteer Sharp needs a compatible browser and the native Linux libraries and fonts required by Chromium. These dependencies aren’t part of the standard managed execution environment. With OS-level dependency support, the application can package those components in its worker image: The .NET isolated function application The .NET isolated Functions worker supplied through the application’s NuGet dependencies Puppeteer Sharp Chromium and its required Linux libraries Fonts and other assets used when rendering the document After the image is deployed to Flex Consumption, an HTTP request invokes the function. Puppeteer Sharp launches the packaged Chromium browser, renders the supplied HTML, and returns the generated PDF. You can explore the complete implementation in the Azure Functions Flex Consumption .NET isolated container sample. A worker-only container model Flex Consumption uses a different container model from other hosting options where the complete Function App runtime is packaged in the customer image. Bring your preferred compatible Linux or language base image to Flex Consumption. As long as the final image satisfies the Flex worker-image contract, you control the base OS, language runtime, application dependencies, and OS-level packages, while Azure provides and maintains the Functions host. Your Flex Consumption container image contains: Your function application One supported Functions language worker Language and application dependencies OS packages, native libraries, browsers, fonts, drivers, executables, and command-line tools required by the application Azure provides and operates: The Azure Functions host and platform components Trigger integration Request and event routing Communication with the language worker Flex Consumption managed scaling This worker-only boundary is important. The feature isn’t arbitrary web-container hosting, and you don’t package or operate the Functions host. You customize the environment in which your function code runs while retaining the Azure-managed Functions programming and scaling model. For broader context on how Azure Functions separates the managed host from the compute that runs your application, see Separating Compute in Azure Functions: Building for scale, efficiency, and reliability. What makes a Flex app registry-backed? A registry-backed Flex app uses the same `Microsoft.Web/sites` resource as a code-package app. The deployment storage type identifies the deployment model: A code-package app uses `properties.functionAppConfig.deployment.storage.type` set to `BlobContainer`. A worker-image app uses the same property set to `Registry`. For a registry-backed app, `deployment.storage.value` contains the fully qualified image reference, and `deployment.storage.authentication` tells Azure how to pull the image. Registry-backed apps omit `functionAppConfig.runtime` because the language runtime and Functions worker are supplied inside the image. properties: { functionAppConfig: { deployment: { storage: { type: 'Registry' value: '<registry>/<repository>:<tag-or-digest>' authentication: { type: '<authentication-type>' } } } // No runtime property for a Registry-backed app. } } Other Function App configuration, including scale and concurrency settings, remains part of the resource and should be preserved when changing the deployment model. See the complete documentation for authentication options, Azure CLI commands, and the complete resource shape. How it works The end-to-end flow is straightforward: Start with the sample Dockerfile for your supported Functions language. Add the OS packages and native dependencies required by your application. Test the source application locally using the normal Functions development experience. Build and scan the linux/amd64 image, then push it to a supported registry. Configure the Flex Consumption app with the fully qualified image reference. Deploy and validate the complete image integration in Azure, then monitor it through logs and Application Insights. For deterministic deployments and rollback, use an immutable image digest for each release. When you need to update the language worker, runtime, base image, OS packages, or application dependencies, rebuild and test the image, push a new version, and update the function app to reference it. Microsoft publishes supported worker artifacts or packages, depending on the language, along with sample Dockerfiles, but doesn’t provide a Flex Consumption base image. You select and maintain the Linux or language base image that meets your application and organizational requirements. When should you use this feature? Use OS-level dependency support when you want the Flex Consumption programming and scaling model but your function requires software that can’t be supplied through the language package manager alone. Examples include: Browser automation with Chromium and Puppeteer PDF generation with Chromium and Puppeteer Sharp Data encryption and signing with GnuPG Image, audio, or video processing with native libraries Database drivers or vendor-provided native SDKs Custom fonts required for document generation Linux executables and command-line tools invoked by application code This capability isn’t intended as a blanket replacement for other Azure Functions hosting options or general container platforms. Choose it when Flex Consumption fits your workload and OS-level dependencies are the missing requirement. Public preview considerations During the preview, keep these considerations in mind: The preview is currently available in East Asia, West Central US and North Europe, and is rolling out to additional Azure regions over the next few weeks. Use only the documented Functions languages and supported language versions. Images must target Linux amd64. Durable Functions isn’t supported. The Azure Service Bus extension (trigger and output bindings) isn’t supported. Availability zone support isn’t available. The preview doesn’t currently provide a supported experience for running the Flex worker container locally. Continue to test the source application locally and validate the complete image integration in Azure. You are responsible for selecting, securing, scanning, patching, rebuilding, testing, and redeploying the base image, language worker, application dependencies, and OS-level dependencies in your image. Preview capabilities and limitations can change. See the complete documentation for the current language versions, configuration procedures, registry authentication options, operational behavior, and known limitations. Get started Start with the sample for your preferred language: .NET isolated container sample Python container sample Node.js container sample Go container sample Read Use OS-level dependencies via containers with Azure Functions Flex Consumption for the complete image contract and deployment guidance. Try the preview with a workload that needs Chromium, GnuPG, a native library, a driver, a font, or another Linux dependency and share what this capability enables for your application!133Views0likes0CommentsAzure SRE Agent brings on-demand, AI-powered operations to your ACA workloads
Today at Microsoft Ignite, we’re introducing on-demand, AI-powered operations help, powered by Azure SRE Agent. Now in preview, this new experience is built right into the Azure Container Apps portal. Developers can start an interactive debugging session directly from any container app and get evidence-backed, actionable insights in minutes. Each session is serverless and on demand: it starts in seconds, stays focused on your question, and ends when you’re done. There’s no agent infrastructure for you to set up, run, or maintain. Azure Container Apps is the first service to bring this experience to customers, and we plan to extend it to more Azure services in the future. Expert answers, right where you work Checking a deployment, reviewing how an app scales, or tracking down an issue usually means piecing together configuration, revisions, deployment history, and metrics from several tools. That takes time and operational expertise that isn’t always on hand. The agent brings that expertise directly into the developer workflow, so teams get answers the moment they need them and can get back to building. You can ask the agent about any aspect of your app. For example: Understand your app: “How is this app configured, and what does it depend on?” Check a deployment: “Did my last deployment change anything that could affect traffic?” Review scaling and performance: “Why is my app scaling out so often?” Spot risks early: “Is anything in this configuration likely to cause problems?” Troubleshoot an issue: “Why did my latest revision fail to start?” How it works Getting started takes a click. From any app in the Azure Container Apps portal, select Debug with SRE Agent and ask your question. The agent already knows which app you’re looking at, so there’s no evidence to gather or context to explain first. Before it reads anything, the agent tells you what it wants to look at and asks for your approval. From there, it works through your app’s configuration, revisions, deployment history, Azure Monitor metrics, and logs from Log Analytics, much like an experienced SRE would. If something is unclear, it asks a focused follow-up question. When it’s done, it walks you through what it found, shows the evidence behind it, and recommends what to do next. Throughout, the agent works with your own Azure identity and sees only what you already have permission to see. Your Azure credentials stay in your browser, and you can review any data before it’s shared with the agent. The agent is read-only, so it never changes your resources and only proposes fixes, and each session runs in an isolated sandbox that’s deleted when the session ends. The sandbox restricts egress and prevents user data from being stored or shared; the only record of the session is a transcript that you can download from the browser after the session has ended. After a session In most cases, you can act on the agent’s recommendation directly in your app. When an issue requires further assistance, the agent can draft a support request from the session for you to review and submit to Azure Support. Sessions give you answers in the moment. To bring that same intelligence to your entire environment, every day, you can deploy Azure SRE Agent right from the session. Once deployed, it builds lasting context and automates the longer-running workflows that keep your apps running. SRE Agent is rolling out in preview in the Azure Container Apps portal. Start a session on any of your apps to see what it can do and let us know how it went with the quick “How was your experience” prompt at the end of each session. Key benefits No setup: Start a session from any container app, with nothing to deploy or configure. Answers in minutes: Get the likely root cause and a recommended fix, backed by evidence from your app. Secure by design: The agent uses your own Azure identity, only sees the data you approve, and never changes your resources. Right where you work: Everything begins and ends in the Azure Container Apps portal, with no switching between tools. Faster time to resolution: Solve common issues on your own without any wait time, and when you need more help, hand off to Azure Support with the context already captured. We have a lot more to show you. Explore all Azure SRE Agent announcements from Ignite 2026 here!78Views0likes0CommentsSeparating Compute in Azure Functions: Building for Scale, efficiency, and reliability.
As customers bring new workloads to Azure Functions, we continue to evolve the runtime to support them securely and at scale. Compute Separation is part of that work. We're revisiting how the host and language workers are deployed and managed to improve efficiency and reliability, and to enable new capabilities while preserving the Functions programming model. When a Functions app needs more capacity, the work you want to scale is its language worker and customer code. In the co-located, out-of-process hosting model, adding that capacity also adds another Functions host, even if the existing host capacity could coordinate more workers. The language worker is already a separate process, but the platform's unit of scale is still the instance that contains both host and worker. Compute Separation changes that unit of scale. The host and the workers run on separately managed compute, allowing the platform to add workers without creating a host for each one. For customers, that opens up more control over the environment running their code, while the platform retains responsibility for the Functions host. Getting there means revisiting assumptions that were convenient when both components lived in the same instance: access to application files, who starts and replaces a process, and even which side opens the connection. One of the most consequential constraints was networking. Existing workers connect to the host, but the platform's networking model requires the remote connection to run in the other direction. This post follows the engineering decisions behind that change, the cold-start and reliability requirements that shaped it, and how we're building and proving the architecture in small end-to-end steps. Preview scope: Everything in this article describes a preview implementation that is still in progress. It is not a released product contract or a migration recommendation. We expect the architecture, behavior, and scope to change as we implement features and validate performance and reliability. Why change the host-worker boundary? The host and the language worker do different jobs. The host connects the app to the platform's control model and implements the runtime-side contract used for worker assignment, readiness, scaling, and reliability actions. It also understands the Functions execution model: it loads trigger and binding extensions, discovers functions, manages listeners, and coordinates invocations. The language worker understands how to load and execute your code in its language runtime. Process isolation already separates these responsibilities into different processes. Compute Separation also separates their compute and lifecycle. Keeping those components together made several things straightforward. The host could start a child process, communicate over localhost, and treat process exit as a direct signal that its worker had stopped. Configuration and application files were available in the same deployment environment. Those conveniences also created dependencies. Scaling the worker repeated the host's resource overhead. A language-specific image carried the host and its dependencies as well as the language runtime. Host maintenance and application image maintenance were coupled. Consider an application that needs native libraries or a particular operating-system dependency. A customer-provided worker image should let you package that environment without also packaging and maintaining the Functions host. You'd own your application, language runtime, dependencies, and image maintenance. The platform would own the host. Custom worker containers are the first customer-facing scenario we're using Compute Separation to enable. The architecture has broader value, though. A host fix shouldn't inherently require rebuilding every language-specific application image. Adding customer execution capacity shouldn't require repeating the full host. Independent release and scaling decisions become possible, subject to protocol compatibility and the capacity of each component. There is a platform-efficiency motivation too. Keeping combined host-and-worker environments warm fragments capacity by language, version, and instance size. A language-independent runtime gives us more options for reusing warm runtime capacity without preparing every combined environment. That is an architectural opportunity, not a measured cold-start improvement or a customer pricing claim. The goal is to preserve the Functions programming model while changing how its components are operated. Functions still execute in language workers, and trigger and binding behavior still needs to hold across the new boundary. Challenge: the worker couldn't initiate the remote connection In the co-located model, the host listens for a connection and the language worker connects to it. Moving the host to another compute instance might suggest replacing a localhost address with a remote endpoint. The platform's network security model rules out that approach. Once separated, worker pods run customer code, so they aren't allowed to open outbound connections to runtime pods. Any connection between the two has to be initiated by the runtime. One option was to change the workers' connection behavior. That would have had a significant compatibility impact across existing worker implementations. It would also have introduced a worker contract tied to the networking needs of this particular hosting model. We wanted to keep those deployment details out of the language workers. We introduced a platform-owned WorkerProxy between the two sides. The runtime opens an authenticated TLS FunctionRpc stream to WorkerProxy. The language worker connects to WorkerProxy over the worker pod's local network, retaining the worker-initiated connection pattern. WorkerProxy bridges the two connections. Each worker pod contains WorkerProxy and a separate container for the language worker and customer code. WorkerProxy provides the transport bridge and worker-side lifecycle contract. It doesn't become a second Functions host, start the customer process, or take ownership of platform placement and pod deletion. For workers that negotiate HTTP streaming, there is also a separate data path: the host forwards HTTP through WorkerProxy's assigned HTTPS origin to the worker's local HTTP endpoint. Requests still pass through the host. On the runtime side, the preview uses a dedicated Functions.Host executable with a client-backed worker composition. The ordinary co-located host retains its server-backed path. We can develop the new topology without making every existing app switch to it. This preserves an important part of worker compatibility, but doesn't eliminate all protocol work. Remote startup also needs configuration, metadata, and extension delivery. Keeping the connection pattern familiar is different from promising that every existing worker version supports the complete new hosting model. Preview limitations and why they exist The networking constraint affects more than the main connection. The FunctionRpc stream isn't the only conversation between a worker and the host. Some extensions add their own communication paths, where code in the worker calls back into components running in the host. In the co-located model, those calls never leave the instance. In the new topology, they become worker-initiated calls to a remote host, which is the direction the networking constraints rule out. WorkerProxy bridges the main stream, but these additional paths are specific to each extension and carry their own protocols and expectations. Supporting them requires changes in both the host and the extensions. Some of that work was more complex than the initial preview's scope and timeline allowed, so the first preview has extension limitations. Service Bus and Durable Functions are the most visible examples. Service Bus message settlement relies on one of these paths: when a function explicitly settles a message, for example to complete or dead-letter it, the worker asks the host-side extension to perform that operation. Durable Functions has a similar dependency. Operations such as starting an orchestration or raising an event go from the worker to APIs that the Durable Functions extension exposes in the host. Neither extension is supported in the first preview, and host and extension work to address these limitations is in progress. Challenge: protecting cold-start performance Cold-start performance was the key performance requirement shaping the design. Separating compute adds networking and coordination to activation. Optimizing steady-state invocation forwarding would not be enough if starting an application became slower. Activation spans networking configuration, specialization of a host instance for the application, initialization of the application container, and linking the worker to the host. Treating all of that as one serial sequence would make each step's latency part of the wait for useful execution. We designed the activation process to overlap independent work while keeping its dependencies explicit. An assignment can arrive before the language worker starts. Other steps really do need to wait: the host must validate initialization before accepting a link, and invocation dispatch must wait for application setup. The requirement is to parallelize preparation without treating partial progress as readiness. The host-side startup path illustrates those distinctions: Assignment configures the worker side. WorkerProxy accepts application and function-group identity, limits, and the HTTP origin when needed. Assignment acceptance doesn't prove that the customer process has initialized. The runtime establishes and validates the link. It connects to WorkerProxy and validates worker initialization, application proof, and delivered host configuration before accepting the link. Application preparation continues. Advertised extensions are prepared before the initialized signal is published. Metadata acquisition and ScriptHost construction and setup follow. The channel becomes eligible for dispatch. The current application-host setup and channel-readiness checks determine when the worker can receive invocations. A successful Link response is therefore an intermediate checkpoint, not permission to send traffic. Platform status publication is another checkpoint, not proof that the entire serving path has converged. Smaller worker images and more reusable warm runtime capacity give us opportunities to improve startup. Neither establishes the result on its own. Cold-start measurements need to cover the full activation path, including scheduling, image availability, networking, specialization, and linking. Application setup without a shared filesystem Activation also exposed a dependency inside the host: it previously had local access to the customer's deployment. A remote host still needs configuration, function metadata, and binding extensions before it can run the app. For host configuration, the compute host advertises the HostConfiguration=1 capability during initialization. A compatible worker returns a typed envelope containing the configuration, and WorkerProxy relays it. The host validates the delivery rather than asking the proxy to interpret the customer's host.json . Malformed configuration fails admission instead of silently becoming defaults. The selected configuration source stays stable across later worker links and child-host restarts. Adding execution capacity must not silently reconfigure an app because another worker connected. Consistency between workers' configuration and function definitions still needs to be validated. Extensions make the boundary more interesting. Customer function code runs in the worker, but host-side binding extensions still run in the host. The preview implementation can receive an advertised extension archive over the connection, validate and extract it, and prepare those assemblies before extension discovery and listener startup. The host can therefore start without a shared customer deployment mount, but it still has application-specific dependencies. Moving files across the connection doesn't add the extension-specific communication paths described earlier or qualify every binding. Those behaviors also have to work across the new boundary. Challenge: preserving reliability without owning the process The co-located host could observe and manage its worker as a child process. With independent compute, the platform owns process creation and replacement. Existing host logic has to participate in that lifecycle through explicit contracts while preserving recovery behavior. A lost connection, for example, is no longer equivalent to a child process exiting. It tells one component that communication stopped; it doesn't prove what the other component is doing. Admission, draining, and replacement need coordinated decisions rather than assumptions based on local process state. That starts with knowing where work can run. The scheduler selects a ready, non-draining worker in the function's group, using a round-robin preference. For HTTP, a full worker is skipped; if all eligible workers are full, admission waits for capacity. A FIFO gate orders invocation attempts, not execution or completion. Listeners need to follow that capacity too. The preview gates supported pull-based listeners on workers for their function group, so the runtime doesn't keep acquiring events with no corresponding worker available. Push-based triggers and shared listeners need different handling. Preserving trigger semantics requires more than a generic worker-selection policy. When is an invocation actually finished? Planned scale-in requires a precise answer. The host closes new admission, withdraws the worker from usable capacity, and drains accepted work before terminating or unlinking the channel. The platform then remains responsible for physically removing the pod. Accepted work includes invocations still buffered or converting input. HTTP adds another case: a worker can send a successful gRPC invocation response while the HTTP response body is still being forwarded to the caller. Removing the worker at that point can truncate a response even though the invocation protocol reported success. The implementation tracks completion through dispatch and, for proxied HTTP, through response forwarding. Worker retirement waits for that lifecycle. This is a useful example of how a familiar operation, stopping a worker, acquires a more explicit contract once its pieces run independently. Unexpected runtime loss follows a separate path. In the current implementation, WorkerProxy enters a sticky removal-requested state and rejects new work, leaving removal and replacement to the platform. It doesn't transparently attach another runtime or replay invocations. Separate compute boundaries also change the failure scenarios we need to test. A worker failure need not require restarting the host, but a runtime failure can affect several workers for the same application. Independent scaling doesn't eliminate shared dependencies. Challenge: carrying platform services across the boundary The host-worker connection now crosses a network and compute boundary. Authenticating the caller, associating a worker with the right application, and handling credentials become explicit parts of the design. The preview implements TLS, runtime caller tokens, and application-key proof during initialization. Those mechanisms are not a claim that the security contract is finished. The implementation documents limitations in certificate identity validation, shared-key authority, and replay protection. Provisioning, network policy, revocation, and cross-application containment remain part of qualification. Managed identity illustrates how platform integration also affects startup. Application code can need an identity token before worker initialization completes. If identity access depended on completed initialization, startup could wait on itself. The preview includes an opt-in Token Service proxy. WorkerProxy carries the worker's local identity request over the existing runtime-initiated stream, and the host forwards it to the host-side Token Service. That path can operate before the customer's worker stream starts. The application gets access to the operation it needs without moving the upstream Token Service credential into the worker-side forwarding contract. Diagnostics and metering need the same attention to ownership. A failure now involves a runtime, a worker pod, and a connection session; logs need to let us distinguish them while preserving the customer logging path. One runtime can dispatch to several workers, so execution measurements need to identify the worker that actually accepted an invocation. The preview records that attribution at dispatch and tracks completion against the selected worker. Binding and extension work can happen before admission, though, so the worker's execution window doesn't cover the whole invocation pipeline. Those records are part of the accounting work, not a final billing definition. Proving the change one end-to-end outcome at a time The initial checkpoint deliberately used one worker and one HTTP request. Even that small scenario crossed platform assignment, the host's outbound link, worker metadata, readiness publication, and both the HTTP and FunctionRpc paths. It gave us a bounded way to exercise the new connections and contracts together. From there, the work expands along several related dimensions: starting an app without a shared deployment mount, executing correctly as worker capacity changes, integrating with platform services, and qualifying the customer experience. These are parallel workstreams with shared contracts, not sequential releases. Figure 3. An explanatory grouping of overlapping engineering workstreams, with dependencies and validation feedback. This is not an availability timeline. Each step needs an observable outcome. Can another worker join without restarting the application host? Can an early identity request complete during startup? Can a worker drain while its HTTP response is still streaming? Can a non-HTTP trigger preserve its binding and execution behavior? These questions cross repository and component boundaries. The host provides components and contracts, while placement, networking, frontend routing, image delivery, language-worker support, and rollout involve other parts of the platform. A merged host change isn't evidence that the whole service path is ready. Small end-to-end scenarios let us test those interactions before broadening coverage. They also let us revise a contract after learning from it, rather than treating a successful connection as proof that startup, execution, and recovery are complete. What remains to prove The next evidence has to cover the full application workload. Cold-start and scale-out measurements need tail latency and image-cache misses, as well as the activation path under normal conditions. Steady-state tests need to quantify network and proxy overhead. Capacity tests need to establish how many workers a runtime can safely coordinate. Compatibility is another qualification task. We need full fidelity with the existing model to ensure applications continue to run with no modifications. What this makes possible The payoff we're working toward is concrete: customers can own the environment running their code without maintaining the Functions host, and the platform can scale and service those components independently. Custom containers are the first scenario, but the value extends beyond packaging. Separate compute gives the host and workers their own CPU and memory resources. A worker that misbehaves is less likely to take resources away from the host or affect the rest of the app, though work assigned to that worker can still fail. We can also allocate capacity to each role independently, rather than adding host overhead whenever we add workers. That gives us room to use resources more efficiently. This separation also gives us a foundation for more advanced deployment options and more flexible scaling. Customer containers can be smaller because they no longer need to include the host and its dependencies. These are opportunities, not capabilities or performance results we can claim for this preview. We've explored this architecture in internal prototypes. It's exciting to see it making its way into the service and opening up new scenarios for customers, starting with custom worker containers. We also plan to extend this model transparently to existing apps, so current customers can benefit without changing how they build and run their apps. We still have work to do to implement the features and validate the performance, but the direction is clear. Separating the host from the worker gives every Functions app a more reliable and efficient foundation, and opens the door to capabilities we couldn't build with both roles sharing the same compute.101Views0likes0CommentsWhat's new in Azure Functions durable task scheduler: Durable agents, disaster recovery, and more
There's been a lot happening with the Azure Functions durable task scheduler lately. Here's a quick look at what's new: Durable agents: The Durable Extension for Microsoft Agent Framework is generally available, durable execution with DTS for LangGraph is in preview, and Pydantic AI now includes Azure Durable Task as a built-in durability option. Native disaster recovery and task queues: Both are now in public preview. Private endpoints and customer-managed keys: Both are now generally available. Durable Task Go SDK: Now available in preview. Whether you're running business workflows, processing event-driven pipelines, or coordinating AI agents, here's what these updates mean for your apps and how to get started. What is the Durable Task Scheduler? If you're new to the Durable Task Scheduler, it's a fully managed durable execution backend for workflows and agents on Azure. It saves progress as work runs, so applications can recover from interruptions without starting over. Completed steps whose results have been saved can be reused, and workflows can wait for human input or external events without keeping a worker active just to wait. DTS handles task scheduling, state persistence, and recovery. Its built-in dashboard lets you inspect execution history and manage running orchestrations. The DTS dashboard shows the execution timeline of a travel-planning workflow, including agent calls and a wait for approval. DTS runs separately from your application. Use it with Durable Functions, the Durable Task SDKs, or supported agent framework integrations, including the Durable Extension for Microsoft Agent Framework. Your application code can run anywhere in Azure, including Azure Functions, Azure Container Apps, and Azure Kubernetes Service. Already using DTS? Here's what's new. Durable execution in agent SDKs Agents and workflows need more than conversation history to recover from interruptions. They might call several tools, start a long-running job, or wait for someone's approval. If a worker restarts halfway through, the application needs to know which steps completed and what should happen next. Durable execution saves that progress, so agents and workflows can run for minutes, days, or weeks and resume from recorded progress after worker or container restarts, scaling events, or infrastructure failures. Retry policies help handle transient errors such as rate limits and timeouts. Completed model calls, tool calls, and activities whose results have been saved can be reused during recovery, reducing repeated work and token costs. Conversation context remains available, and workflows can wait for approvals or external events for hours or days without keeping a worker active just to wait. You can bring these durable execution capabilities to agents and workflows built with Microsoft Agent Framework, LangGraph, or Pydantic AI. Here's how to get started with each: Microsoft Agent Framework: The Durable Extension is generally available for .NET and Python. Keep your core agent logic and coordinate durable agents and multi-agent workflows with Durable Task orchestrations or Agent Framework graphs. See the GA blog post and samples. LangGraph: In public preview. Add DTS to existing Python graphs, ReAct agents, and Deep Agents on Azure without rewriting your graph logic. Pydantic AI: Azure Durable Task is now available as a durability capability in Pydantic AI Harness. Use it with Durable Task orchestration and worker setup to persist model and tool results and recover agent execution without building your own checkpointing or recovery system. Native disaster recovery is now in public preview Native disaster recovery for Azure Functions durable task scheduler is now in public preview. For business-critical workflows and applications with cross-region recovery requirements, it provides a way to resume work in another region from replicated state rather than starting workflows over. Pair your primary scheduler with a secondary in another Azure region, and DTS replicates orchestration and entity state to the secondary. When you need to fail over, you can promote the secondary and resume work from that replicated state. Learn more: Disaster recovery documentation. Task queues are now in public preview Task queues for Azure Functions durable task scheduler are now in public preview. Group orchestration and activity work into named queues within a task hub and control how quickly DTS delivers that work to workers. This helps teams pace batch processing and give different workloads their own dispatch-rate budgets without creating separate task hubs. For workloads that call downstream services, it provides a way to manage how quickly work is dispatched. Create a queue, configure its work-item delivery rate, and select it using the DTS_TaskQueue tag when scheduling work. For a closer look at how task queues work and an example of how to use them, see Task queues in Durable Task Scheduler. Learn more: Task queues documentation and SDK examples. Private endpoints are now generally available Private endpoints for Azure Functions durable task scheduler are now generally available for both Consumption and Dedicated SKU schedulers. Connect your applications to DTS through a private IP address in your virtual network using Azure Private Link. Traffic stays on the Microsoft backbone instead of traversing the public internet. You can also disable public network access so your scheduler accepts connections only through private endpoints. Applications continue to use the same scheduler endpoint and Microsoft Entra authentication. Learn more: Configure private endpoints for DTS. Customer-managed keys are now generally available Customer-managed keys for Azure Functions durable task scheduler are now generally available for Dedicated SKU schedulers. Organizations that need to manage their own encryption keys can now use customer-managed keys to protect their workflow data, supporting separation of duties, centralized auditing of key access, and customer-defined key rotation policies. Use a key you own in Azure Key Vault or Azure Managed HSM to protect scheduler data at rest. Configuration is available through the ARM REST API, Azure CLI using az rest, or Bicep. Learn more: Configure customer-managed keys for DTS. The Durable Task Go SDK is now available in preview Writing your application in Go? You can now build durable workflows with the Durable Task Go SDK, available in preview. Write your orchestrations and activities in Go, and let DTS take care of durable state and dispatching work. You can chain activities, run work in parallel, wait for external events, and use durable timers. Retry policies help you handle failures, and orchestration management APIs let you manage execution. Start locally with the DTS emulator, then connect your application to a scheduler in Azure when you're ready. You'll need Go 1.25 or later, and DTS is currently the SDK's only supported runtime. Get started: Go SDK documentation, DTS quickstart sample, and Go sample catalog. Get started with the Durable Task Scheduler If you're new to DTS, start with the documentation and samples. You can develop locally with the emulator, then choose the Consumption or Dedicated SKU based on your workload's pricing and capacity requirements. We'd love to hear your feedback, especially as you try the new previews. Share questions and feedback through the Durable Task Scheduler GitHub repository.98Views0likes0CommentsWhat's new in Azure Functions and Durable Task Scheduler at Microsoft Ignite 2026
At Microsoft Ignite 2026, we're announcing a significant set of updates across Azure Functions and Durable Task Scheduler. Read the full summary and technical breakdown covering Managed Connectors (GA), custom containers on Flex Consumption, durable execution and enterprise controls for AI and stateful workloads, Hosted Skill and agent bindings, Go (GA) and .NET 11 (GA), and new CLI and networking diagnostics.512Views0likes0CommentsWhat's new in Azure Container Apps at Ignite'26
Azure Container Apps (ACA) is a fully managed serverless container platform that enables developers to design and deploy microservices and modern apps without requiring container expertise or needing infrastructure management. With built-in autoscaling (including scale to zero), per-second billing, advanced networking, and built-in observability, ACA lets teams focus on their code instead of their clusters. Since Build’26 we have continued to innovate on two fronts: Azure Container Apps Sandboxes, which provide secure, isolated environments where agents can run untrusted code, and the infrastructure behind Microsoft’s agent platforms that customers can use to build their own agent platform, and Azure Container Apps Express, the fastest way to deploy a container image as an internet-reachable app, with no environment to provision. Both are now generally available, and this blog covers everything we are announcing at Ignite’26. The agentic world is changing the workloads coming to ACA Agents don’t just answer questions anymore; they run code, call tools, deploy endpoints on demand, and work for hours on a task. That shifts what platforms need to deliver: instant startup, strong isolation for code nobody has reviewed, scoped identity and network access, and the ability to scale to zero and back when the work is done. ACA was built for exactly this shape of workload, and customers across industries are building on it: Nous Research runs Hermes Agent workloads on ACA Sandboxes, where agent execution happens in isolated microVMs that start in under a second and release compute when idle Discovery Bank runs its agent-assist and Discovery AI applications on Azure Container Apps, hosting lightweight APIs, business logic, and orchestration that connect its contact center, Azure Databricks, and Azure OpenAI to deliver personalized banking experiences with scalable, low-latency responses Crowe uses ACA autoscaling workers to asynchronously process lease documents, extract and verify key terms, and deliver audit reports that flag higher-risk leases for human review Photon Education uses ACA alongside Azure Functions to run specific Classwise microservices, separating content management, real-time interactions, and background processing from the core app so AI-powered classroom features stay responsive and reliable Ghassan Aboud Holding runs the GrandChef AI shopping agent and its APIs on ACA, which scales with demand and powers recipe and preference-based product recommendations and cart building in the Grandiose app BKW uses ACA as part of an Azure-native MCP server that makes AI weather and geospatial insights available to agentic workflows, supporting energy and infrastructure decisions with human oversight WTW uses ACA as a scalable hosting environment for Radar Vision’s application services, supporting its event-driven platform that analyzes insurer performance and delivers near-real-time, AI-generated insights to pricing, underwriting, and claims teams Templafy uses ACA Sandboxes to give an AI agent isolated, disposable workspaces where it can clone repositories, run tools, and explore code to answer engineering and product questions without exposing internal systems Azure Container Apps Sandboxes are now generally available Introduced in preview at Build’26, ACA Sandboxes are now generally available. Sandboxes are a first-class resource type alongside apps, jobs, and dynamic sessions, enabling you to build your own agent platform with your choice of framework, lifecycle services, and governance, designed with zero-trust security provisions. Each sandbox is an isolated microVM that boots from cached images in under a second, can be suspended with its full memory and disk state snapshotted, and resumes in under a second. Stopped sandboxes incur no compute charges, and a single sandbox group can burst to thousands of concurrent sandboxes. The GA release includes lifecycle controls, snapshots, an egress proxy with host allowlists, deny policies and credential injection, virtual network integration, persistent volumes, and telemetry export, along with the Python and TypeScript SDKs, the aca CLI, Bicep, and a preview Terraform provider. Sandboxes are quickly becoming the Azure standard for customers to build agent platforms and multi-tenant SaaS. The same infrastructure already runs cloud sandboxes in GitHub Copilot, Foundry Hosted Agents, Azure SRE Agent, and Azure Container Apps Express. The pattern is simple: govern the agent in Microsoft Foundry, and let its work run in a disposable sandbox with scoped identity and network access. To get started, see the Sandboxes overview. Azure Container Apps Express is now generally available ACA Express, which we introduced in preview in May, is now generally available. You bring a container image, and Express handles the rest: no environment to provision, no networking to configure, and no scaling rules to write. Apps are running in seconds, start from zero in well under a second, scale to and from zero automatically, and are billed per second. Express runs on Azure Container Apps Sandboxes and is available in more than 40 Azure regions. ACA Express is gaining momentum since launch, with customers creating Express apps across thousands of Azure subscriptions, growing at >35% MoM. Alongside this new adoption, we’re automatically moving eligible existing apps to Express, so more customers can benefit without needing to manage the transition themselves. These migrations are designed to improve performance while preserving the features and capabilities those apps already use. Express is getting closer to feature parity with Consumption, and the rest of the features are coming soon. Express is purpose-built for developers who want to ship fast (SaaS apps, APIs, web dashboards, and prototypes) and for agents that deploy on demand (MCP servers, tool-use endpoints, and human-in-the-loop UIs). To learn more, see the Express overview. Introducing built-in interactive integration of Azure SRE Agent in Azure Container Apps ACA has built-in integration with Azure SRE Agent. The Container Apps portal now has a first-class experience for interactive debugging with SRE Agent, launched in preview. Developers can start a session from any container app and get evidence-backed, actionable root cause analysis and expert answers in minutes, with nothing to deploy. Each session is serverless and on demand. It starts in seconds, stays focused on your question, and ends when you’re done. ACA is the first Azure service to bring this experience to customers, and we plan to extend it to more services in the future. Getting started takes a click. Select Debug with Azure SRE Agent on any app and ask your question in your own words, for example “Why did my latest revision fail to start?” or “Why is my app scaling out so often?” The agent already knows which app you are looking at, asks for your approval before it reads anything, and then works through your app’s configuration, revisions, deployment history, Azure Monitor metrics, and Log Analytics logs, much like an experienced SRE would. It runs read-only with your own Azure identity, so it never changes your resources and only proposes fixes, and each session runs in an isolated sandbox that is deleted when the session ends. When an issue needs more help, the agent can draft a support request for you to review and submit to Azure Support, or you can deploy Azure SRE Agent right from the session to bring that intelligence to your entire environment. Azure Container Apps is now a target in Azure Migrate We are announcing that Azure Container Apps is now available as a target in Azure Migrate. Azure Migrate can discover and assess Java web apps running on Apache Tomcat and .NET web apps running on .NET Core, and help you plan the move to ACA with a wave plan. The migration then continues in GitHub Copilot app modernization, which handles code changes, containerization, and deployment. Together they give teams a single path from discovery to a running container app. See Migrate to Azure Container Apps with Azure Migrate to learn more. Additional Enhancements and Ecosystem Updates More regions: Since Build’26 we have continued to expand ACA’s global footprint, adding six new regions: Germany North, New Zealand North, Chile Central, Korea South, Belgium Central, and Jio India Central. Express is available in more than 40 Azure regions. New tooling in VS Code: Azure Container Apps Sandboxes are now integrated directly into Visual Studio Code, making it easier to create and manage secure, isolated environments without leaving your development workflow. Developers can execute commands, create snapshots, and manage sandbox lifecycle directly from the ACA extension. Bring your own orchestrator to ACA Jobs: ACA Jobs are a great fit for batch processing, ETL, machine learning, and other tasks that run to completion, but many teams already have an orchestrator. The new Bring Your Own Orchestrator collection provides 13 community-maintained templates for connecting the workflow engine you already use, such as Airflow, Temporal, Argo Workflows, Dagster, Prefect, Durable Functions, and Logic Apps Standard, to ACA Jobs. You keep your control plane, and ACA Jobs runs the work on serverless, scale-to-zero infrastructure. Join us at Ignite and stay in touch We have a full lineup of sessions at Ignite’26. Come meet the ACA team, see demos of Sandboxes, Express, and Azure SRE Agent, and hear from customers running agents in production. Breakout 448: Run secure agent loops in production with isolated sandboxes at scale Lab 722: Operate secure, multi-tenant agentic apps on Azure Container Apps Theater Session 901: The agentic path from legacy apps to AI-native on Azure Container Apps Lightening Talk 1279: Deploy AI apps effortlessly with Azure Container Apps Express Theater Session 1026: Your existing apps, your next decade of cloud-native Lightening Talk 1293: Design serverless architectures for speed, cost efficiency and AI apps Table Talk 1847: Lessons learned: What it takes to run AI agents in production Breakout 423: Build AI-native with Azure's agentic application platform Can’t make it? We want to hear from you either way. Share feedback, ask questions, and follow our roadmap and monthly product updates on the Azure Container Apps GitHub repository, and open an issue to tell us what you want to see next. Thank you for building with Azure Container Apps.171Views2likes0CommentsIntroducing Azure Container Apps as a target workload in Azure Migrate
We are excited to announce Azure Container Apps as a target workload for assessment in Azure Migrate, helping organizations evaluate existing web applications for migration to a managed, serverless container platform. This capability extends the Azure Migrate assessment experience to Azure Container Apps, bringing application readiness, migration requirements, sizing recommendations, and estimated hosting costs into migration planning. Organizations can identify suitable applications, understand the changes required, and make informed decisions before starting migration. Supported workloads include Web Apps discovered through Azure Migrate Make informed modernization and migration decisions For organizations with an existing application estate, modernization starts with a few essential questions: Which applications are suitable for container-based hosting? What needs to change? What resources will they require, and what will they cost to run? Azure Migrate helps answer these questions through discovery and assessment. With Azure Container Apps as a workload target, migration teams can: Assess application readiness: Evaluate existing web applications for migration to Azure Container Apps. Identify migration requirements: Review compatibility issues, warnings, and recommended remediation. Review resource recommendations: Understand the compute requirements of the assessed applications. Estimate hosting costs: Use assessment estimates to support migration decisions and budgeting. Plan migration waves: Turn assessment insights into manageable migration batches. These insights help migration teams and application owners establish a shared understanding of migration scope, effort, and priorities. Why Azure Container Apps? Azure Container Apps enables organizations to run containerized applications without managing servers or the underlying container orchestration infrastructure. The platform supports web applications, APIs, microservices, and background processing, with capabilities including: Automatic scaling based on HTTP traffic or event-driven rules, including scale-to-zero for supported configurations. Managed ingress for application endpoints. Application revisions and traffic splitting to support controlled updates. Connectivity to dependent services, including databases, storage, and messaging. Adding Azure Container Apps as an assessment target helps organizations evaluate these capabilities against the requirements of existing applications before migration begins. From discovery to migration 1. Discover existing web applications Start with an Azure Migrate project and configure the Azure Migrate appliance for the source environment. Discovery builds an inventory of web applications and their hosting servers. Review the discovered applications and dependency information to establish the assessment scope. Review discovered web applications and select workloads for assessment. The inventory includes discovered workloads; discovery alone does not establish readiness for Azure Container Apps. 2. Assess for Azure Container Apps Create a web app assessment for the selected applications and choose Azure Container Apps as the target. Configure the applicable assessment settings, including target region and sizing preferences, then run the assessment to generate readiness findings, resource recommendations, and estimated costs. Create an assessment for the discovered web app workloads. 3. Review results and decide Review the assessment findings to understand which applications are ready for migration and which require changes. Evaluate migration issues alongside business criticality, application dependencies, and operational requirements. Use these insights to select applications for migration and prioritize modernization work. Navigate to the Azure Container Apps tab for more details on the readiness Review readiness and estimated monthly costs for Azure Container Apps. This example shows three web apps ready for migration and one not ready, with a cost estimate for the three ready apps. Estimates vary by workload and assessment settings. 4. Plan migration waves After selecting the migration path, use Azure Migrate wave planning, to organize assessed applications and workloads into migration batches. Review the proposed waves, sequencing, dependencies, and risks. Refine assignments with application owners and stakeholders, then commit approved waves. Committing a wave accepts the migration plan; it does not start migration. The approved scope and assessment findings provide the foundation for application preparation and deployment. 5. Migrate to Azure Container Apps Continue the approved migration plan in GitHub Copilot app modernization, using the Azure Migrate assessment findings, application scope, and dependency information as context. The tooling handles application code changes, validation, containerization, and deployment to Azure Container Apps. Follow the workflow for the application's language: Java: Migrate with GitHub Copilot app modernization, including containerization and deployment to Azure Container Apps. .NET: GitHub Copilot modernization overview and deployment workflow. Get started Assess existing web applications for Azure Container Apps and move forward with a migration grounded in application readiness, resource requirements, and cost insights. Explore the resources: Azure Migrate overview Azure Container Apps overview Migrate to Azure Container Apps with Azure Migrate Containerize Java Web Apps and Migrate to Azure Container Apps - Azure Migrate256Views0likes0CommentsDurable Task extension for Microsoft Agent Framework is now Generally Available
Today, we’re excited to announce the general availability of the Durable Task extension for Microsoft Agent Framework. It brings the reliable execution model of Durable Task to Agent Framework, helping agents and agentic workflows recover from failures and interruptions without losing their progress. Saving a conversation is only part of the story. When an agent is doing work, your application also needs to know which steps have finished, which jobs are still running, and whether it’s waiting for someone’s approval. If the application restarts, that information makes the difference between continuing the work and figuring out where to begin again. The Durable Task extension keeps track of that state for you. Agents can continue the same conversation after a worker restart, and workflows can pick up interrupted work without repeating steps whose results have already been saved. They can also wait for approvals or external events without keeping a worker running. You can focus on what your agents do, with less state management and recovery code to build yourself. Run durable agents and workflows in Azure Functions, or self-host them in your own .NET or Python application. Key capabilities of the Durable Task extension The Durable Task extension adds two capabilities to Microsoft Agent Framework that work together: durable agents and durable workflows. Durable agents keep conversation and session state between requests. Each agent call runs through Durable Task, so saved session state stays available even if a worker restarts or another application instance handles the next request. The conversation can continue without relying on the original process. Durable workflows keep track of work that takes multiple steps or runs over time. You can write Durable Task orchestrations to coordinate agent calls, application activities, and external events. If you prefer Agent Framework’s graph-based workflows, the extension runs those graphs as Durable Task orchestrations and handles registration of their agents and executors. The two come together when an interactive agent needs to start work that won’t finish in a single request. The agent can launch a workflow and return its instance ID rather than keep the user waiting. The workflow continues independently, including waiting for results or approvals. The agent can use that ID later to check progress or send an event, such as an approval decision. The examples below show how this works in practice: continuing a conversation, coordinating work across multiple steps, waiting for someone’s input, and managing session state and model context. Later in the post, we’ll show how to set up the host that runs these examples. Agent sessions that survive interruptions Suppose a customer starts a support conversation, then comes back with their order number. In between, your application restarts or another worker takes over. The agent should be able to pick up the conversation where it left off. Agent Framework can keep sessions in memory or use a persistent history provider to save messages between requests. A durable agent builds on that with a managed path for running agent calls and restoring session state, so you don’t have to wire that together yourself. With the Durable Task extension, each conversation has a stable durable session ID, and saved session state lives outside the worker process. Your application keeps the session reference. When the customer returns, another compatible worker can use that reference to continue the same conversation. The examples below show two separate requests. The first starts the conversation and serializes its session reference, which your application must save for later use. Serialization alone does not save it. The later request loads that reference and reconnects to the same durable session, without needing the original session object. Both requests use the same Durable Task backend, with SupportAgent registered through the extension. C# using System.Text.Json; using Microsoft.Agents.AI; using Microsoft.Agents.AI.DurableTask; // First request: start the conversation and return its session object. static async Task<JsonElement> StartConversationAsync( IServiceProvider services) { AIAgent agent = services.GetDurableAgentProxy("SupportAgent"); AgentSession session = await agent.CreateSessionAsync(); await agent.RunAsync( "I need help with my order.", session: session); // SerializeSessionAsync returns only the lightweight JSON session reference // (containing the durable session ID); Durable Task already stores the // conversation history in the backend. return await agent.SerializeSessionAsync(session); } // Later request, after a restart or on another compatible worker. // Load savedSession from your application's durable storage before calling. static async Task<AgentResponse> ContinueConversationAsync( IServiceProvider services, JsonElement savedSession) { AIAgent agent = services.GetDurableAgentProxy("SupportAgent"); AgentSession session = await agent.DeserializeSessionAsync(savedSession); return await agent.RunAsync( "The order number is 12345.", session: session); } Python from typing import Any from agent_framework import AgentResponse from agent_framework_durabletask import ( DurableAIAgentClient, DurableAgentSession, ) # First request: start the conversation and return its serialized session reference. def start_conversation( durable_client: DurableAIAgentClient, ) -> dict[str, Any]: agent = durable_client.get_agent("SupportAgent") session = agent.create_session() agent.run("I need help with my order.", session=session) # to_dict() returns only the lightweight session reference dict (containing # durable_session_id); Durable Task already stores the conversation history # in the backend. return session.to_dict() # Later request, after a restart or on another compatible worker. def continue_conversation( durable_client: DurableAIAgentClient, saved_session: dict[str, Any], ) -> AgentResponse: agent = durable_client.get_agent("SupportAgent") session = DurableAgentSession.from_dict(saved_session) return agent.run("The order number is 12345.", session=session) Coordinate multi-step agentic workflows reliably A simple customer question can lead to several steps: look up records, prepare a response, and send it to the right person or system. If something interrupts the process halfway through, your application needs to know what has already finished and what still needs to happen. Durable Task saves the results of agent calls and activities as the workflow progresses. After an interruption, the orchestration replays its history, reuses saved results, and continues with unfinished work. Completed agent calls whose results have been recorded don’t need to call the model again during replay, avoiding unnecessary token usage and inference costs during recovery. C# // Registered as the Durable Task orchestration for this workflow. static async Task<string> RunOrderResponseWorkflowAsync( TaskOrchestrationContext context, string orderNumber) { DurableAIAgent agent = context.GetAgent("OrderAgent"); AgentSession session = await agent.CreateSessionAsync(); AgentResponse<TextResponse> summary = await agent.RunAsync<TextResponse>( message: $"Summarize order {orderNumber}.", session: session); AgentResponse<TextResponse> reply = await agent.RunAsync<TextResponse>( message: $"Draft a customer reply: {summary.Result.Text}", session: session); return reply.Text; } Python # Registered as the Durable Task orchestration for this workflow. def run_order_response_workflow( context: OrchestrationContext, order_number: str, ): agent_context = DurableAIAgentOrchestrationContext(context) agent = agent_context.get_agent("OrderAgent") session = agent.create_session() summary = yield agent.run( messages=f"Summarize order {order_number}.", session=session, ) reply = yield agent.run( messages=f"Draft a customer reply: {summary.text}", session=session, ) return reply.text Make graph-based workflows durable If you prefer to build workflows as graphs in Agent Framework, you can use that approach too. The Durable Task extension runs your graph as a durable orchestration, keeping track of its progress so it can recover from failures and interruptions. You only need to register the graph. The extension takes care of registering its agents, activities for the other executors, and the orchestration that runs it. C# Workflow expertTeamWorkflow = new WorkflowBuilder(questionParser) .WithName("ExpertTeamReview") .AddFanOutEdge(questionParser, [biologist, physicist]) .AddFanInBarrierEdge([biologist, physicist], responseAggregator) .Build(); services.ConfigureDurableWorkflows( options => options.AddWorkflow(expertTeamWorkflow)); Python expert_team_workflow = ( WorkflowBuilder( name="ExpertTeamReview", start_executor=question_parser, ) .add_fan_out_edges( source=question_parser, targets=[biologist, physicist], ) .add_fan_in_edges( sources=[biologist, physicist], target=response_aggregator, ) .build() ) # agent_worker wraps the Durable Task worker. agent_worker.configure_workflow(expert_team_workflow) As agents and executors finish their work, Durable Task saves their results and reuses them during replay. You define how the work connects in the graph, and Durable Task handles preserving progress and recovering execution. Human in the loop Sometimes an agent needs someone to review a draft, approve an action, or provide more information before the work can continue. That response might take an hour, a day, or longer. Keeping a worker running just to wait can add cost and prevent the application from scaling down. With the Durable Task extension, the workflow can save its progress and wait for an external event without keeping a worker active. When the person responds, an HTTP endpoint, agent tool, or other application code sends the event to the matching workflow instance. The orchestration picks up from its saved state and continues the work. C# // Registered as the Durable Task orchestration for this workflow. static async Task<string> RunContentReviewWorkflowAsync( TaskOrchestrationContext context, GeneratedContent draft) { await context.CallActivityAsync(nameof(NotifyReviewer), draft); HumanApprovalResponse decision = await context.WaitForExternalEvent<HumanApprovalResponse>( eventName: "HumanApproval", timeout: TimeSpan.FromHours(24)); if (!decision.Approved) return "Content was not approved."; await context.CallActivityAsync(nameof(PublishContent), draft); return "Content published."; } // From the approval endpoint or agent tool, outside the orchestration: await client.RaiseEventAsync(instanceId, "HumanApproval", approvalResponse); Python # Registered as the Durable Task orchestration for this workflow. def run_content_review_workflow( context: OrchestrationContext, draft: dict[str, str], ): yield context.call_activity("notify_reviewer", input=draft) decision = yield context.wait_for_external_event("HumanApproval") if not decision["approved"]: return {"status": "not-approved"} yield context.call_activity("publish_content", input=draft) return {"status": "published"} # From the approval endpoint or agent tool, outside the orchestration: client.raise_orchestration_event( instance_id=instance_id, event_name="HumanApproval", data={"approved": True}, ) Observe agents and workflows in one place When your application uses the Durable Task Scheduler as the durable backend, you can see what your agents and workflows are doing in the Durable Task Scheduler dashboard, whether they run in Azure Functions or a self-hosted application. Open an agent session to review its conversation history, see the timeline of its execution, and check reported token usage. For workflows, you can check their status and see how the work has progressed through the timeline, event history, and flow views. Open an individual step to inspect its inputs and outputs, understand what happened, or investigate a failure. Build with the Durable Task extension You can run durable agents and workflows in Azure Functions, or host them in your own .NET or Python application. The examples below show how to register your agents and workflows with the host that runs them. They assume you’ve already defined the agents, workflow graphs, and orchestration functions. Hosting environment .NET Python Azure Functions Microsoft.Agents.AI.Hosting.AzureFunctions agent-framework-azurefunctions Self-hosted applications Microsoft.Agents.AI.DurableTask agent-framework-durabletask Azure Functions Azure Functions gives you managed HTTP endpoints and scales with demand. To get started, add Microsoft.Agents.AI.Hosting.AzureFunctions for .NET or agent-framework-azurefunctions for Python to your Functions project, and configure its Durable Task backend. C# example for Azure Functions Register standalone agents and agents used by your own orchestrations with ConfigureDurableAgents. For Agent Framework workflow graphs, use ConfigureDurableWorkflows. You can use either method on its own or combine them to host agents and graphs in the same application. using IHost app = FunctionsApplication .CreateBuilder(args) .ConfigureFunctionsWebApplication() .ConfigureDurableAgents(options => options.AddAIAgent(agent)) .ConfigureDurableWorkflows(options => options.AddWorkflow(workflow)) .Build(); app.Run(); For a Durable Task orchestration, mark its entry point with [Function] and [OrchestrationTrigger] so Azure Functions can discover it. If you register an Agent Framework graph, the extension creates the supporting orchestration for you. Python Pass standalone agents and agents used by your own orchestrations to AgentFunctionApp through the agents argument. For an Agent Framework graph, use the workflow argument. You can provide either or both. from agent_framework_azurefunctions import AgentFunctionApp app = AgentFunctionApp( agents=[agent], workflow=workflow, ) For a Durable Task orchestration, mark its entry point with app.orchestration_trigger(context_name="context"). For an Agent Framework graph, AgentFunctionApp adds that trigger for you. The C# Functions samples and Python Functions samples show the full project setup and how to call your agents and workflows. Self-hosted applications You can also run durable agents and workflows in your own application with Microsoft.Agents.AI.DurableTask for .NET or agent-framework-durabletask for Python. You choose where the application runs and how users or other systems call it. Durable Task handles saving execution state and recovering work after interruptions. C# example for self-hosted applications Configure the Durable Task worker and client, register your agents, and add any Agent Framework graphs. using IHost host = Host.CreateDefaultBuilder(args) .ConfigureServices(services => { services.ConfigureDurableAgents( options => options.AddAIAgent(agent), workerBuilder: builder => builder.UseDurableTaskScheduler(connectionString), clientBuilder: builder => builder.UseDurableTaskScheduler(connectionString)); services.ConfigureDurableWorkflows( options => options.AddWorkflow(workflow)); }) .Build(); await host.RunAsync(); For a Durable Task orchestration, also register it through AddTasks in the workerBuilder callback. For example, this registers the earlier order-response function and passes it the orchestration input: workerBuilder: builder => { builder.UseDurableTaskScheduler(connectionString); builder.AddTasks(registry => registry.AddOrchestratorFunc( "RunOrderResponseWorkflow", (TaskOrchestrationContext context) => RunOrderResponseWorkflowAsync( context, context.GetInput<string>() ?? throw new ArgumentException( "An order number is required.")))); } The scheduler integration requires Microsoft.DurableTask.Worker.AzureManaged and Microsoft.DurableTask.Client.AzureManaged alongside the extension. Python example for self-hosted applications Pass your configured Durable Task worker to DurableAIAgentWorker, then register your agents, orchestrations, and workflow graphs before starting the worker. from agent_framework_durabletask import DurableAIAgentWorker agent_worker = DurableAIAgentWorker(worker) # Register an agent and an orchestration you wrote directly. agent_worker.add_agent(order_agent) worker.add_orchestrator(run_order_response_workflow) # Register a graph and let the extension configure its components. agent_worker.configure_workflow(workflow) worker.start() Register only the components your application needs, or combine them in the same worker. Your application keeps the worker running and calls worker.stop() when it shuts down. When you deploy, configure your Durable Task Scheduler endpoint, task hub, and authentication. Durable Task Scheduler is the recommended backend for Durable Functions and the Durable Task SDKs. Start with a sample You don’t have to start from scratch. Pick a sample for your language and hosting environment, and build from there: - .NET Azure Functions samples - .NET self-hosted samples - Python Azure Functions samples - Python Durable Task samples Read the Durable Task extension documentation to get started, and share feedback or contribute in the Microsoft Agent Framework Durable Task extension repository1.5KViews1like0Comments