Microsoft Agent Framework .NET 1.19.0: Persistence, MCP Tasks, and Durable Agents

Microsoft Agent Framework .NET 1.19.0 is a state-and-hosting release more than a cosmetic version bump. The August 22 release adds session-persisted chat-client routing, Azure Blob Storage session persistence, hosted-agent state in Microsoft Foundry, experimental agent-hooks interception, and resilient long-running Foundry Hosted Agent support. It also contains a breaking MCP long-running-task migration to the 2026-07-28 Tasks extension.

For teams already using the .NET SDK, the practical question is not simply whether to update the package. It is whether your application owns conversation state safely, whether hosted agents can resume work after failure, and whether your MCP integrations are ready for the new Tasks contract.

At a glance: Microsoft Agent Framework .NET 1.19.0 is useful for production teams that need durable sessions, Foundry-hosted state, or more reliable long-running agent work. Treat the MCP Tasks migration as a compatibility checkpoint before deploying.

What changed in .NET 1.19.0

Microsoft’s official dotnet-1.19.0 release was published on August 22, 2026. The release notes list these changes among the most consequential items:

• Session-persisted chat-client routing.
• Azure Blob Storage session persistence.
• Persisted hosted-agent state in Foundry.
• An experimental agent-hooks interception contract.
• Resilient, long-running, and steerable Foundry Hosted Agents.
• A breaking migration of MCP long-running task support to the 2026-07-28 Tasks extension.
• Fixes for A2A streaming artifacts, AG-UI context forwarding, Harness file-tool descriptions, and GitHub Copilot resume reasoning summaries.

The NuGet record for Microsoft.Agents.AI 1.19.0 independently confirms the package version and shows compatibility with .NET 8.0, .NET Standard 2.0, and .NET Framework 4.7.2. The package record also lists the related abstractions and extensions that must remain version-compatible.

Upgrade first, then choose a state strategy

The base package can be updated with the .NET CLI:

1dotnet add package Microsoft.Agents.AI --version 1.19.0

Most applications will also use provider or hosting packages. Keep the Agent Framework package family aligned instead of upgrading only one assembly. For a solution using central package management, update the version in Directory.Packages.props and run the full test suite:

1<ItemGroup>
2  <PackageVersion Include="Microsoft.Agents.AI" Version="1.19.0" />
3  <PackageVersion Include="Microsoft.Agents.AI.Abstractions" Version="1.19.0" />
4</ItemGroup>

Do not assume that a successful restore proves compatibility. Exercise streaming, tool calls, approvals, session restore, and every MCP operation that can outlive a single request.

The state boundary to preserve

Microsoft Learn describes AgentSession as the conversation state container used across agent runs. A session can hold local state and, for some providers, a service-side conversation identifier. That distinction matters in a multi-tenant application: a provider-issued identifier is not an authorization boundary.

Keep the mapping in application-owned storage:

1Authenticated user/tenant
2        |
3        v
4Application session ID  --->  AgentSession + provider conversation ID
5        |                              |
6        +-- ownership check ------------+
7                       |
8                       v
9                 Agent Framework run

A safe request flow resolves the client-visible session ID only after authenticating the caller and checking tenant ownership. Do not accept a raw conversation_id or previous_response_id from an untrusted client and pass it directly to the provider.

Persist sessions without coupling them to one worker

The release adds Azure Blob Storage session persistence for .NET. The architectural goal is simple: a request can land on another worker without losing the application’s conversation state.

There are two different persistence problems:

1. Conversation history — the messages and provider state needed to continue a conversation.
2. Agent execution state — approvals, tool-loop context, todos, background-task state, or workflow checkpoints.

A durable design makes both explicit. Store serialized sessions under an application-owned continuation key, use a durable history provider where appropriate, and protect the storage account with managed identity and least-privilege access. Set retention and deletion rules; conversation state is data with privacy and cost implications, not an unlimited cache.

The Microsoft Agent Framework session documentation also warns that sessions are agent- and service-specific. Do not restore a serialized session into a different provider or materially different agent configuration without testing the behavior.

Foundry Hosted Agents: what the release changes operationally

The release notes add persisted hosted-agent state in Foundry and support for resilient, long-running, and steerable Foundry Hosted Agents. These changes target work that cannot be treated as one synchronous HTTP request: research jobs, approval-gated tasks, multi-step workflows, and external-event waits.

A resilient loop should make progress observable and resumable:

The important production behavior is not that every task becomes magically reliable. Your application still needs idempotent tools, bounded retries, clear cancellation semantics, and an audit trail for approvals. Durable execution reduces the amount of state you must rebuild after a crash; it does not make unsafe side effects safe to repeat.

For an Azure Functions deployment, Microsoft Learn’s Durable Extension documentation describes Azure Functions and self-hosted deployment models. It covers session persistence, workflow checkpointing, failure recovery, distributed execution, human-in-the-loop waits, and reliable streaming when a suitable stream broker is configured.

The MCP breaking change deserves a migration test

The .NET 1.19.0 notes mark the migration of MCP long-running task support to the 2026-07-28 Tasks extension. This is the item most likely to break an otherwise clean package upgrade.

Before rollout, test the complete lifecycle rather than only the initial tool call:

Do not silently translate old and new task payloads in a middleware layer unless you can test both directions. A compatibility shim can hide a protocol mismatch until a long-running production job reaches an edge case.

Agent hooks: useful interception, dangerous centralization

The release introduces the agent-hooks interception contract as an experimental feature. Interception can help implement consistent policy around prompts, tool invocation, telemetry, and approvals. It can also become a hidden control plane that makes debugging difficult.

Use hooks for cross-cutting concerns with narrow responsibilities:

• Validate and redact sensitive tool arguments.
• Attach correlation IDs and tenant context.
• Record approval and policy decisions.
• Enforce explicit allowlists for high-impact tools.
• Fail closed for policy checks that protect data or external side effects.

Avoid putting business logic, prompt rewriting, or provider-specific recovery behavior in a global hook until you have tracing that shows the original request, transformed request, decision, and outcome. Keep the feature experimental in your risk register and test behavior after each framework update.

A practical .NET 1.19.0 rollout checklist

1. Pin the entire Microsoft Agent Framework package family to compatible versions.
2. Read the official release diff from 1.18.0 and identify packages used by your solution.
3. Add tests for session serialization and restore across a fresh process.
4. Verify that provider conversation IDs are never used as tenant authorization.
5. Run MCP long-running-task tests against the 2026-07-28 Tasks extension.
6. Test streaming, AG-UI, A2A, Harness tools, approvals, and GitHub Copilot resume paths if enabled.
7. Configure durable storage with managed identity, encryption, retention, and access logging.
8. Make external tools idempotent or add deduplication keys before enabling retries.
9. Exercise cancellation, timeout, replay, and partial-failure behavior.
10. Roll out behind a feature flag and compare error rates before widening traffic.

If your application only performs short, stateless chat requests, the release may not justify an immediate migration. If it runs hosted agents, MCP tasks, or approval-heavy workflows, the state and durability changes make a controlled upgrade worth prioritizing.

How this fits with the broader Agent Framework stack

The existing Microsoft Agent Framework Python 1.15.0 upgrade guide covers a parallel Python release, but the package families and migration details are not interchangeable. The Agent Framework Harness guide is useful when your .NET application exposes a coding-agent style harness with tools, approvals, and persistent context.

If your architecture crosses the protocol boundary, pair the upgrade review with the MCP stateless HTTP migration guide. Treat framework versioning and protocol versioning as separate compatibility axes.

Common upgrade mistakes

Updating only the root package

Provider, hosting, workflow, and abstraction assemblies can impose their own version constraints. Restore the complete solution and inspect the dependency graph rather than assuming transitive resolution is sufficient.

Persisting IDs without ownership metadata

A service-side conversation ID can resume the wrong user’s context if it is stored without tenant ownership and accepted from the browser. Use an opaque application ID and enforce authorization on every resume.

Retrying side effects blindly

Durable retries can repeat a payment, deployment, email, or database mutation. Add idempotency keys and record side-effect completion before enabling automatic replay.

Treating experimental hooks as stable API

Keep hook registration isolated and covered by contract tests. Make removing or disabling hooks a reversible deployment change.

FAQ

Is Microsoft Agent Framework .NET 1.19.0 a major version?

No. It is a 1.x minor release, but it includes a marked breaking MCP long-running-task migration. Semantic version numbering does not remove the need to read the release notes.

Does .NET 1.19.0 require .NET 10?

The NuGet package record lists compatibility with .NET 8.0, .NET Standard 2.0, and .NET Framework 4.7.2. Confirm your exact target framework and dependency graph in CI before deployment.

Should every app enable Azure Blob Storage session persistence?

No. Use durable session storage when conversations or agent execution must survive process restarts and scale-out. Stateless, short-lived requests may not need the operational and retention costs.

Is the .NET release the same as Python 1.15.0?

No. They are related releases in the same framework but have different version numbers, package layouts, and release notes. Follow the guidance for the SDK you actually deploy.

Conclusion

Microsoft Agent Framework .NET 1.19.0 is a practical upgrade for teams moving from single-request agents toward persistent, hosted, and recoverable agent systems. Start with the MCP Tasks compatibility test, then validate session ownership, serialization, durable storage, retries, and side-effect safety. The safest rollout is a controlled one: align package versions, prove restore behavior across workers, instrument the long-running path, and only then widen production traffic.

Sources and visual credits

• Microsoft Agent Framework dotnet-1.19.0 release — primary release source.
• Microsoft.Agents.AI 1.19.0 on NuGet — independent package record and compatibility metadata.
• Microsoft Learn: Session — session lifecycle and ownership guidance.
• Microsoft Learn: Durable Extension — durable hosting and persistence guidance.
• MCP 2026-07-28 Tasks extension release — protocol migration reference.
• Mermaid flow diagram — original diagram created for this article from the documented session, checkpoint, and recovery concepts.