Azure Functions Dynamic Workflows moves an important boundary in AI-assisted integration: a model can propose a plan, while a durable runtime executes the work. Microsoft introduced the capability in its 17 September 2026 announcement for Azure Functions hosted skills. The practical opportunity is not to let a chatbot run the enterprise. It is to make bounded, evidence-gathering work recoverable, observable and independent of a single conversation.
For an integration team, this is worth evaluating when investigations involve several systems, delayed evidence or expensive model round trips. My starting point would be an integration incident assistant with read-only access. Keep order submission, financial posting and replay authorization behind deterministic services until the operational and security controls have earned your trust.
What Azure Functions Dynamic Workflows changes
A hosted skill can ask the runtime to start a structured workflow and receive an identifier immediately. Independent activities can execute in parallel, waits use durable timers, and intermediate results stay outside the conversation. Durable Functions supplies the execution foundation. The distinction is between choosing the work and maintaining its execution state.
The current hosted-skills project model is Python v2. Microsoft documents Flex Consumption, Premium and Dedicated hosting options. Do not assume every language supported by ordinary Durable Functions is therefore supported by this hosted-skills authoring model. Also, read preview configuration carefully: names and supported capabilities may change before general availability. The official product references are linked at the end.
For architecture reviews, the useful question is now: which decisions genuinely require reasoning, and which actions must remain fixed? A model may decide that an incident needs gateway evidence and queue evidence. It should not decide that an unverified business transaction is safe to replay simply because a log message suggests doing so.
Separate reasoning, execution and authority
I would design three boundaries. The reasoning layer selects permitted evidence operations. The execution layer tracks progress and survives interruptions. The authority layer decides which identities can read data or change business state. Combining all three in a powerful prompt creates an unnecessary failure domain.
Consider delayed orders between an API gateway, a message broker and an ERP adapter. The assistant collects gateway failures, queue age and recent deployment changes. It produces a review packet that distinguishes observed facts from possible causes. A separate operator workflow approves any replay. That division lets teams evaluate the new runtime without making a model the owner of transaction integrity.
A bounded incident-investigation workflow
- 1. Accept and scopeValidate incident identity, tenant and time window. Issue a business correlation ID.
- 2. Plan permitted workThe hosted skill proposes evidence tasks. The runtime starts a validated workflow.
- 3. Execute durablyCollect independent evidence, join results and preserve progress outside the conversation.
The Enterprise Integration Patterns connection
Think of this as a new way to drive a Process Manager, not a new delivery guarantee. A coordinator decides what happens next using the evidence available. Parallel evidence collection resembles Scatter-Gather; the result joins resemble an Aggregator. The completeness condition matters more than the diagram: does the report require all three sources, or can it explicitly mark one unavailable?
The Correlation Identifier belongs to the business investigation. Keep it alongside the workflow identifier, individual tool attempts and any later remediation request. A second workflow investigating the same incident should not erase the first investigation’s identity. Likewise, an Idempotent Receiver remains necessary wherever repeated execution can create an external effect.
These are architecture interpretations, not claims that the preview implements an EIP catalog automatically. For the wider integration context, see Hybrid Integration Architecture: 12 Patterns in One Flow. The same boundaries apply when a governed API fronts an existing middleware process.
Build a deliberately small first implementation
1. Define a measurable operational problem
Choose a recurring investigation: “Why are accepted orders not reaching the ERP?” Establish a baseline from recent incidents. Record the time to assemble evidence, the number of manual console visits and the proportion of reports that contain a useful next action. Faster text generation is not a useful success metric if operators still repeat every lookup.
Restrict the pilot to one interface family and one environment. Agree which evidence is safe to expose and how long it can be retained. Give the owning operations team a clear fallback: the existing dashboards and runbook must still work when the model provider is unavailable.
2. Enable workflows without widening permissions
Start from Microsoft’s hosted-skills quickstart and pin a tested dependency set. The following front matter illustrates the documented enablement switch in an otherwise configured project. It is not a complete deployment or a tested production sample:
---
name: Integration Evidence Review
description: Assemble a read-only incident review packet.
builtin_endpoints: true
workflows:
enabled: true
---
Gather only the evidence permitted for this incident.
Separate observations from hypotheses.
Do not initiate remediation or replay transactions.Use built-in endpoints only in an appropriately protected evaluation environment. A sentence prohibiting remediation is guidance, not access control. Do not register a replay capability for this assistant, and do not grant its identity write access to the transaction service.
3. Make tools narrow and predictable
The documented workflow-tool contract requires a synchronous Python handler, one dictionary argument and a JSON-serializable result. Register it explicitly with @workflow_tool in the tools directory. Microsoft warns that worker failures can repeat execution. Ordinary chat tools do not become safe just because they are available.
Design a tool such as “read queue age for this approved interface,” not “execute arbitrary KQL against any workspace.” Validate the interface and tenant against server-side authorization context. Clamp time windows, restrict fields, set network timeouts in the client and cap returned rows. Return timestamps and source identifiers so an operator can verify the evidence.
Keep raw business payloads out of the report unless they are essential and approved. An error count, oldest-message age and redacted exception category may answer the question without copying customer records. If evidence is incomplete, return that state explicitly rather than an empty array that looks like a healthy system.
4. Close the result-delivery loop
Starting a workflow is not completing an incident investigation. Define where the final review packet is stored, who can read it and how the operator learns it is ready. Queue-driven work needs an explicit delivery path; there is no waiting chat user to receive the result automatically.
My proposed review record would include the incident ID, workflow ID, evidence window, individual source states, findings, confidence limitations and a report version. Commit that record through a deterministic persistence operation. A notification should link to the stored record rather than become the only copy of the result.
Durability is not exactly-once business processing
The dangerous failure occurs between an external effect and recording its success. Suppose a tool creates a remediation ticket, then the worker fails before the completion is recorded. Re-execution can create another ticket. Restartable orchestration does not make the ticketing system transactional with the workflow store.
Use a stable business-operation key at the receiving service. For example, combine the incident ID with a defined operation type and report version. Have the receiver atomically reserve that key and return the existing outcome for repeats. A separate “check, then create” sequence can still race when two workers arrive together.
Do not derive the key from a fresh random value on each attempt. Equally, do not treat a new workflow ID as proof of a new business operation. Where the downstream API cannot support an atomic duplicate guard, keep the pilot read-only or place a controlled service in front of it. Microsoft’s idempotency guidance is a useful baseline; the concrete concurrency contract remains your implementation responsibility.
Preview limits that change the adoption decision
The current documentation does not support static workflow templates authored in YAML or Markdown, configurable per-task retry and timeout policies, large-output handling, or MCP Tasks integration. It also describes isolated workflow subagents whose failures can fail their parent. Treat these limits as design inputs, not details to discover during an outage.
If an interface requires a reviewed, fixed execution path, retain a code-defined Durable Functions orchestration or an explicitly designed Logic Apps workflow. If every backend call needs distinct retry budgets, prove the required behavior before choosing this preview. Do not invent unsupported configuration fields to make a sample look production-ready.
For a hybrid estate, place the experiment beside the existing integration path. Read status through governed endpoints; do not give the assistant direct database credentials merely to save a connector call. The pilot should be removable without changing how orders, invoices or customer updates flow.
Security and operations need their own acceptance tests
Model-visible evidence is untrusted input. A log entry can contain customer text, an attacker-controlled URL or instructions to ignore the runbook. Tool authorization must not depend on whether the model follows a prompt. Enforce identity, allowed resource scope and output destinations in code or service policy.
Also inventory everything stored outside the model context. Moving intermediate results to a workflow store changes where data persists; it does not remove its sensitivity. Set retention, access and audit requirements for reports and execution history. Use opaque identifiers rather than secrets in correlation fields.
Assign an operator to each failure state. Alert on investigations that exceed the agreed age, repeated tool failures, missing completion records and unexpected cost growth. A model’s final sentence is not your monitoring system. Correlate the execution with the telemetry platform; my Azure Monitor ingestion migration guide covers the reliability of that separate reporting path.
| Inject this failure | Required evidence |
|---|---|
| Restart a worker during collection | The investigation reaches a known state without duplicate external effects. |
| One evidence API returns an error | The report distinguishes unavailable evidence from a clean result. |
| Submit the incident twice | Business-operation keys prevent duplicate writes where writes are permitted. |
| Put hostile instructions in a log message | The assistant cannot gain additional authority or redirect data. |
| Cancel a running investigation | Operators can account for completed effects and unfinished work. |
Measure total cost, not just tokens
Keeping intermediate data out of repeated model conversations can reduce token usage. However, parallel work can increase pressure on APIs, storage and monitoring. Benchmark the complete investigation, including failed runs, repeated attempts and the operator’s review time.
Compare the existing manual runbook, direct tool calling and a dynamic workflow on the same incident set. Measure end-to-end latency, useful-report rate, missing evidence, model usage and infrastructure consumption. Avoid turning a vendor example into a promised saving for your estate. The best outcome may be a smaller model with a better evidence contract, or a deterministic collector with no model in the execution path.
Production-readiness checklist for the pilot
- Record the preview status, approved use case and accountable service owner.
- Pin and record runtime dependencies, model deployment and tool versions.
- Authorize tools independently of the generated plan and prompt.
- Validate tenant, interface and time-window scope server-side.
- Bound network calls, evidence size, concurrency and result retention.
- Test duplicates and worker interruptions against real receiving contracts.
- Persist a correlated final report; monitor failures in result delivery.
- Document cancellation separately from rollback or compensation.
- Measure incident usefulness and total cost against the existing runbook.
- Keep a working fallback and a switch that stops new investigations.
Frequently asked questions
Is Azure Functions Dynamic Workflows generally available?
No. As checked on 21 September 2026, Microsoft labels hosted skills as preview and the dynamic-workflow surface as experimental v1. Evaluate it under your organization’s preview-service policy.
Should we migrate existing Logic Apps integrations?
Not simply because this capability exists. A stable, known business process does not need a model-generated plan. Start with a bounded investigation or enrichment workload where variable evidence gathering creates a genuine benefit.
Does a durable workflow guarantee that an order is submitted once?
No. External systems still need duplicate protection and an explicit concurrency contract. Plan for repeated activity execution and ambiguous outcomes at network boundaries.
Can cancellation undo completed actions?
Do not design on that assumption. Treat cancellation as execution control. Any required compensation must be a separately designed, authorized business operation with its own audit trail.
What would I implement first?
A read-only assistant that assembles evidence for delayed integrations and produces a review packet. That tests the operational value while keeping remediation in the hands of an accountable operator and deterministic services.
My recommendation
Azure Functions Dynamic Workflows is worth a focused architecture experiment because it separates model-driven planning from durable execution. The business case is faster, better-supported operational decisions—not autonomous control for its own sake. Start narrow, measure the result and expand authority only when the evidence supports it.
Official sources
The release facts and current limits above come from Microsoft. The proposed incident architecture, implementation boundaries and acceptance tests are my design recommendations, not claims of a tested reference deployment.
- Original update: Enable Dynamic Workflows in Azure Functions hosted skills — Microsoft Apps on Azure Blog, published 17 September 2026.
- Hosted skills overview and preview status.
- Dynamic Workflows architecture and current limitations.
- Create and run Dynamic Workflows.
- Hosted skills configuration reference.
- Designing Azure Functions for identical input.
- Durable Functions overview.





0 Comments