What's new in Aspire 13.2

Aspire 13.2 brings significant improvements to the developer experience with enhanced CLI capabilities, dashboard improvements, new AI agent integrations, and better multi-language support. This release focuses on making local development more streamlined while maintaining the robust cloud-native foundation that Aspire is known for.

Aspire 13.2 supports:

.NET 8.0 Long Term Support (LTS)
.NET 9.0 Standard Term Support (STS)
.NET 10.0 Long Term Support (LTS)

It’s important to note that Aspire releases out-of-band from .NET releases. While major versions of Aspire align with major .NET versions, minor versions are released more frequently. For more information on .NET and Aspire version support, see the Aspire support policy.

🆙 Upgrade to Aspire 13.2

For general purpose upgrade guidance, see Upgrade Aspire.

The easiest way to upgrade to Aspire 13.2 is using the aspire update command:

Update your Aspire project using the aspire update command:
Aspire CLI — Update all Aspire packages
```
aspire update
```
Update the Aspire CLI itself:
Aspire CLI — Update the CLI
```
aspire update --self
```

Or install the CLI from scratch:

Bash
PowerShell

https://aspire.dev/install.sh | bash

https://aspire.dev/install.ps1 | iex

You can also manually update your AppHost project file (for example, MyApp.AppHost.csproj) to reference Aspire.AppHost.Sdk version 13.2.0:

<Sdk Name="Aspire.AppHost.Sdk" Version="13.2.0" />

Then check for any NuGet package updates, either using the NuGet Package Manager in Visual Studio or the Update NuGet Package command from C# Dev Kit in VS Code.

If you’re using a JavaScript or TypeScript AppHost, run aspire restore after upgrading so the guest AppHost SDK code and language-specific artifacts are regenerated:

aspire restore

For more details on installing the Aspire CLI, see Install the CLI.

🛠️ Aspire CLI enhancements

Language-specific templates and multi-language setup

Aspire 13.2 makes the aspire new experience much more language-aware. Instead of treating every starter as a .NET-first layout, the CLI now scaffolds language-specific templates for .NET and non-.NET AppHosts and carries the right metadata forward into configuration and generated SDK assets.

The new aspire restore command is part of that story. For .NET AppHosts it restores packages, and for guest AppHosts it regenerates SDK code and required artifacts even when aspire run would otherwise skip regeneration because the package hash hasn’t changed.

# Create a new starter with the interactive template picker
aspire new

# Restore a guest AppHost and regenerate SDK code
aspire restore --apphost .\AppHost\apphost.ts

Detached mode and process management

One of the most requested features lands in 13.2: detached mode for running Aspire applications. You can now run your AppHost in the background, freeing up your terminal for other tasks.

# Run in detached mode
aspire run --detach

# List all running AppHosts
aspire ps

# Stop a running AppHost
aspire stop

The aspire ps command displays all currently running Aspire AppHosts, making it easy to manage multiple projects simultaneously. When combined with aspire stop, you have full control over your application lifecycle directly from the command line.

The new aspire start shortcut makes background AppHost startup easier to remember, and aspire stop can stop a selected AppHost or all running AppHosts. In JSON mode, aspire ps can include resources, which makes it a solid building block for automation and editor integrations.

aspire start --apphost .\MyApp.AppHost\MyApp.AppHost.csproj
aspire ps --resources --format json
aspire stop --all

Resource commands were also reorganized into the aspire resource <resource> <command> form. Built-in commands such as start, stop, and restart now line up more naturally with what the dashboard exposes, and project resources can expose richer commands such as rebuild.

aspire resource api restart
aspire resource api rebuild

Command reference: aspire run, aspire ps, and aspire stop.

Isolated mode for parallel development

The new --isolated flag enables running an AppHost with randomized ports and isolated user secrets:

aspire run --isolated

Isolated mode assigns random ports and creates separate user secrets for each run, preventing port conflicts and configuration collisions. This is particularly useful when switching between different Aspire projects or running integration tests that need dedicated ports.

Environment diagnostics with `aspire doctor`

The new aspire doctor command provides comprehensive diagnostics of your development environment:

aspire doctor

This command checks:

.NET SDK installation and version
HTTPS development certificate status (including detection of multiple certificates)
Container runtime (Docker/Podman) availability and version
WSL2 environment configuration
Container tunnel requirements for Docker Engine
Agent configuration status (detecting deprecated settings)

Not all checks appear in every run. Some checks, such as WSL2 configuration and agent configuration status, are conditional and only appear when the relevant environment or issues are detected.

The output provides actionable recommendations when issues are detected, making it easier to troubleshoot configuration problems.

Enhanced `aspire add` with fuzzy search

Finding the right integration package is now easier with fuzzy search in the aspire add command. Simply start typing and the CLI will suggest matching packages, reducing the friction of discovering and adding new integrations to your project. This release also improves friendly-name generation and better respects central package management.

Command reference: aspire add.

New CLI commands for certificates, exports, secrets, and waits

Aspire 13.2 significantly expands the day-to-day CLI surface area with several new commands.

Certificate and secret management get first-class commands:

aspire certs clean
aspire certs trust

aspire secret set ApiKey super-secret-value
aspire secret list --format json

aspire certs helps you clean stale developer certificates and trust the current certificate, while aspire secret gives AppHost user secrets their own dedicated CLI workflow for setting, reading, listing, locating, and deleting secret values.

Two new operational commands round out the experience:

aspire wait api --status healthy --timeout 120
aspire export --output .\artifacts\aspire-export.zip

Use aspire wait to block automation until a resource becomes healthy, up, or down, and use aspire export to capture telemetry and resource data from a running AppHost into a zip file. You can also scope export to a single resource with aspire export <resource>.

Agent integration (`aspire agent`)

The aspire mcp command has been renamed to aspire agent to better reflect its purpose of managing AI agent integrations. The new command structure includes:

# Start the MCP (Model Context Protocol) server
aspire agent mcp

# Initialize agent environment configuration
aspire agent init

This enables AI agents to interact with your Aspire applications through a standardized protocol, opening up new possibilities for AI-assisted development workflows.

Command reference: aspire agent, aspire agent mcp, and aspire agent init.

To learn how to configure AI agents with Aspire, see Use AI coding agents.

Documentation commands from the CLI (`aspire docs`)

The new aspire docs command brings the official aspire.dev documentation directly into your terminal. Built on the same MCP (Model Context Protocol) documentation tools that power the Aspire agent integration, these commands let you browse, search, and read documentation without leaving your development workflow.

# List all available documentation pages
aspire docs list

# Search for specific topics
aspire docs search "redis"

# Read a full documentation page by its slug
aspire docs get redis-integration

# Read a specific section of a page
aspire docs get redis-integration --section "Add Redis resource"

Each command supports --format Json for machine-readable output, making them useful for scripting and automation. The aspire docs search command also accepts a --limit option to control the number of results returned.

Command reference: aspire docs, aspire docs list, aspire docs search, and aspire docs get.

Improved configuration management

The aspire config command has been enhanced with better organization:

# List all configuration with organized sections and colors
aspire config list

# Get a specific setting
aspire config get <key>

# Set a configuration value
aspire config set <key> <value>

Configuration is now clearly separated into local and global settings, with feature flags displayed in an organized manner.

Aspire now also prefers a single aspire.config.json file that combines AppHost location, language metadata, Aspire SDK version, channel selection, feature flags, launch profiles, and package pins:

{
  "appHost": {
    "path": "apphost.ts",
    "language": "typescript/nodejs"
  },
  "sdk": {
    "version": "13.2.0"
  },
  "channel": "stable",
  "features": {
    "polyglotSupportEnabled": true
  },
  "profiles": {
    "default": {
      "applicationUrl": "https://localhost:17000;http://localhost:15000"
    }
  }
}

This unified format replaces the older split across .aspire/settings.json and apphost.run.json and makes TypeScript AppHosts much easier to move, inspect, and automate.

Command reference: aspire config, aspire config list, aspire config get, and aspire config set.

CLI telemetry

Aspire CLI now includes optional telemetry to help improve the developer experience. Telemetry data is version-consistent with the dashboard, providing a unified approach to usage analytics. All telemetry follows standard privacy practices and can be controlled through configuration.

For more information, see Microsoft-collected CLI telemetry.

CLI option standardization

Several CLI options were standardized for consistency with common CLI conventions:

-v for --version: The -v flag is now a short alias for --version, following standard CLI conventions.
--format descriptions: The --format option description is now standardized to “Output format (Table or Json).” across all commands that support it.
--log-level/-l: Commands that support log-level filtering now use --log-level/-l consistently.

Other CLI improvements

There are plenty of smaller but meaningful CLI improvements in 13.2:

aspire run now supports --no-build for cases where you know the AppHost artifacts are already up to date.
Human-readable status output is routed away from structured JSON output more consistently, making scripts and editors more reliable.
Tables, status indicators, help organization, logging, and error messages were refined across interactive and non-interactive scenarios.
The unified self-extracting Aspire CLI bundle continues to improve Windows and multi-language experiences, especially when .NET isn’t already installed globally.

🌐 Multi-language development

TypeScript AppHost support

Aspire 13.2 continues to expand multi-language capabilities with improved TypeScript support:

AspireList support for TypeScript code generation
TypeScript AppHost testing infrastructure
Multi-language AppHost refactoring for better extensibility

For more details, see Multi-language architecture.

JavaScript and TypeScript AppHost debugging

JavaScript and TypeScript AppHosts now participate in debugging more naturally through the CLI and VS Code extension, with better tool detection, better build and launch coordination, and better support for browser and JavaScript debugging scenarios.

Project reference support and broader exported hosting APIs also make TypeScript AppHosts less special-cased than they were in 13.1. If you’re building on TypeScript or JavaScript AppHosts, 13.2 is a meaningful step up in day-to-day usability.

Aspire panel and VS Code extension improvements

The VS Code extension picked up a substantial set of improvements in this release:

A dedicated Aspire Activity Bar panel shows running AppHosts and resources in a tree view.
A status bar item surfaces AppHost state directly in the editor.
The extension uses a follow-style describe workflow to keep the workspace view current.
Azure Functions debugging support was added.
publish, deploy, and do flows can now be debugged directly from the extension.
The extension can auto-register the Aspire MCP server.
File pickers are used in more places instead of raw string prompts.
A new enableAspireDashboardAutoLaunch setting lets you disable automatic dashboard launch.

This all adds up to a much more polished Aspire experience in VS Code, especially for teams working on multi-language solutions or jumping frequently between the terminal, the dashboard, and the editor.

Template updates for modern frontend stacks

The TypeScript and frontend templates were refreshed for 13.2 with updated dependencies, better starter defaults, and fixes for local development naming issues such as DNS-invalid host names generated with underscores. These changes are small individually, but together they make the starter templates feel much closer to modern production and devcontainer workflows.

Code generation

Go, Java, and Rust code generation test projects added
Common languages SDKs included for broader support

📊 Dashboard improvements

Enhanced data export

The dashboard now provides comprehensive export capabilities:

Export All Button: Quickly export all telemetry data with the new “Export selected” button in the Manage logs and telemetry dialog
JSON Export for Resources: Export resource snapshots as JSON for debugging or automation using the action buttons for each resource
.env File Export: Export environment variables directly to a .env file format from resource details
View JSON with Copy: Download or copy JSON directly from the visualizer

The dashboard can also import telemetry bundles captured with aspire export, making it easy to attach diagnostics to bug reports, preserve a point-in-time view of a session, or share a failing scenario with a teammate.

Improved telemetry visualization

Download JSON for Traces, Spans, and Logs: Each telemetry view now includes options to export data
OTLP/JSON Support: The dashboard now supports OTLP over JSON in addition to gRPC
Environment Variable Highlighting: Environment variables are now highlighted for better visibility
Masked Query String Values: Sensitive data in URLs is automatically masked for security

GenAI visualizer improvements

The GenAI visualizer keeps getting sharper. In 13.2 it handles more schema shapes, tolerates truncated payloads more gracefully, properly displays non-ASCII text, and makes tool inspection easier by letting you jump directly from a tool call to the corresponding tool definition.

Resource graph improvements

The resource graph layout has been significantly improved with adaptive force-directed positioning, providing a clearer visualization of your application topology.

Persistent UI state

The dashboard now remembers:

Collapsed/expanded state of resources
Filter preferences across sessions
View options and settings

Additional dashboard refinements in 13.2:

A 12-hour or 24-hour time format setting.
Consistent resource colors across the dashboard and CLI.
Better JSON viewers for traces, spans, logs, and resources.
Improved handling for large gRPC payloads.
More stable graph layout and filtering behavior.
More polished dialogs, menus, copy flows, and resource details views.

Security enhancements

Dashboard icon and token-based authentication in URLs
Query string value masking to protect sensitive information
Copy button visibility improvements even when values are hidden
Toggle button for secret visibility in input dialogs

For more details, see Explore the Aspire dashboard and Dashboard configuration.

🧩 App model and resource improvements

MCP endpoints from the app model

Aspire 13.2 adds WithMcpServer, which lets you declare in the app model that a resource hosts a Model Context Protocol (MCP) server. Aspire tooling can then discover and proxy that endpoint directly.

var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.MyApi>("api")
    .WithMcpServer("/mcp");

builder.Build().Run();

Project rebuilds and smarter change detection

Project resources now support a rebuild command in addition to the usual lifecycle commands. This gives you a clean way to apply source changes to a single project resource without tearing down the whole AppHost session.

aspire resource api rebuild

Under the hood, Aspire coordinates stop, build, and restart through a hidden rebuilder resource and improved change detection, so the experience is much closer to “rebuild just this one thing” instead of “restart everything and hope.”

Better secret and certificate handling

Container build secrets got a clearer API in 13.2. WithBuildSecret replaces the old WithSecretBuildArg name and makes secure Docker or Podman build secret flows more readable.

var builder = DistributedApplication.CreateBuilder(args);

var accessToken = builder.AddParameter("accessToken", secret: true);

builder.AddContainer("worker", "contoso/worker")
    .WithDockerfile("../worker")
    .WithBuildSecret("ACCESS_TOKEN", accessToken);

Certificate trust handling also became more flexible. You can now create custom certificate bundles during run mode, which helps with scenarios like Java trust stores or custom bundle formats that don’t map cleanly to the default certificate layout.

builder.AddContainer("my-java-app", "my-image:latest")
    .WithCertificateTrustConfiguration(ctx =>
    {
        ctx.EnvironmentVariables["JAVAX_NET_SSL_TRUSTSTORE"] =
            ctx.CreateCustomBundle((certs, ct) =>
        {
            var pkcs12Builder = new Pkcs12Builder();
            var safeContents = new Pkcs12SafeContents();

            foreach (var cert in certs)
            {
                safeContents.AddCertificate(cert);
            }

            pkcs12Builder.AddSafeContentsUnencrypted(safeContents);
            pkcs12Builder.SealWithMac(
                string.Empty, HashAlgorithmName.SHA256, 2048);

            return Task.FromResult(pkcs12Builder.Encode());
        });

        return Task.CompletedTask;
    });

ReferenceExpression now exposes GetValueAsync() and supports conditional mode in multi-language code generation, which makes advanced hosting extensions easier to build without relying on synchronous value access patterns.

Enhanced debugging experience

Several types now include DebuggerDisplayAttribute for better debugging:

DistributedApplication
Resource types
EndpointReferenceExpression
ReferenceExpression
PipelineStep

This makes it easier to inspect your Aspire application state during debugging sessions.

Resource event improvements

Added Logger property to IDistributedApplicationResourceEvent for better logging context
Improved ResourceNotificationService.WaitFor exception messages with more detailed information
BeforeResourceStartedEvent now only fires when actually starting a resource (breaking change)

For more details on eventing, see AppHost eventing APIs.

Docker and container enhancements

WithYarn Fixes: Improved reliability when using Yarn with AddViteApp
‘Never’ Pull Policy: Exposed image pull policy option for scenarios requiring local images
PullPolicy for Docker Compose: Added PullPolicy property to Docker Compose Service class
PostgreSQL v18+ Compatibility: Fixed data volume path for PostgreSQL version 18 and later

Build improvements

Build error when GenerateAssemblyInfo is disabled in AppHost projects
Trailing commas now allowed in launchSettings.json
JSON comments and trailing commas parsed without errors

📦 Integrations updates

Foundry and hosted agents

Aspire 13.2 replaces the earlier AIFoundry-focused hosting surface with a broader Microsoft Foundry integration.

You can now add Foundry resources, attach model deployments, and run against Foundry Local in development:

var builder = DistributedApplication.CreateBuilder(args);

var foundry = builder.AddFoundry("ai")
    .RunAsFoundryLocal();

var chat = foundry.AddDeployment("chat", FoundryModel.OpenAI.Gpt5Mini);

builder.AddProject<Projects.Api>("api")
    .WithReference(chat);

builder.Build().Run();

This release also adds hosted-agent support on top of Foundry, including APIs such as PublishAsHostedAgent and AddAndPublishPromptAgent, which start to bring agent-centric deployment scenarios into the regular Aspire app model.

Azure Virtual Network and private endpoint support

When deploying to Azure, securing network access to your resources is critical. The new Aspire.Hosting.Azure.Network integration lets you lock down your Azure resources by defining virtual networks, subnets, NAT gateways, network security groups (NSGs), and private endpoints directly in your AppHost—ensuring your cloud infrastructure is secure by default.

var vnet = builder.AddAzureVirtualNetwork("vnet");

// Add a subnet with NSG rules
var subnet = vnet.AddSubnet("web", "10.0.1.0/24")
    .AllowInbound(
        port: "443",
        from: AzureServiceTags.AzureLoadBalancer,
        protocol: SecurityRuleProtocol.Tcp)
    .DenyInbound(from: AzureServiceTags.Internet);

// Add a NAT gateway for deterministic outbound IPs
var natGateway = builder.AddNatGateway("nat");
subnet.WithNatGateway(natGateway);

// Add private endpoints for secure connectivity
var peSubnet = vnet.AddSubnet("private-endpoints", "10.0.2.0/27");
var storage = builder.AddAzureStorage("storage");
peSubnet.AddPrivateEndpoint(storage.AddBlobs("blobs"));

Key capabilities include:

Virtual networks and subnets: Create networks with AddAzureVirtualNetwork and add subnets with AddSubnet.
NAT gateways: Provide deterministic outbound public IP addresses with AddNatGateway and WithNatGateway.
Network security groups: Control traffic flow using shorthand methods (AllowInbound, DenyInbound, AllowOutbound, DenyOutbound) or explicit AddNetworkSecurityGroup with WithSecurityRule for full control.
Private endpoints: Securely connect to Azure services over private networks with AddPrivateEndpoint, which automatically creates private DNS zones, virtual network links, and disables public access on the target resource.

For more details, see Azure Virtual Network integration.

Azure AI and embedding support

The Azure AI Inference component now supports embeddings in addition to chat completions. You can register an EmbeddingsClient and then layer an IEmbeddingGenerator<string, Embedding<float>> on top of it:

var builder = WebApplication.CreateBuilder(args);

builder.AddAzureEmbeddingsClient("embeddings")
    .AddEmbeddingGenerator();

var app = builder.Build();

app.MapGet("/embed", async (
    IEmbeddingGenerator<string, Embedding<float>> generator) =>
{
    var embedding = await generator.GenerateEmbeddingAsync("Hello, world!");
    return embedding.Vector.ToArray();
});

For more details, see Azure AI Inference integration.

Azure App Service enhancements

Deployment slot support with new extension methods
Sticky slot app settings fixes
Configuration naming improvements

For more details, see Azure App Service integration.

Azure Container Registry

The Azure Container Registry integration now supports scheduled image cleanup with the new WithPurgeTask method. This provisions an ACR purge task that automatically removes old or unused container images on a cron schedule:

var acr = builder.AddAzureContainerRegistry("my-acr")
    .WithPurgeTask("0 1 * * *", ago: TimeSpan.FromDays(7), keep: 5);

Additionally, the new GetAzureContainerRegistry method makes it easy to access the registry from a compute environment for further configuration.

For more details, see Azure Container Registry integration.

Azure Data Lake Storage integration

Aspire 13.2 adds both hosting and client-side support for Azure Data Lake Storage. This closes an important gap for teams using hierarchical namespace storage and gives Data Lake users the usual Aspire integration benefits: DI registration, retries, health checks, logging, and telemetry.

var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.Api>("api");
var storage = builder.AddAzureStorage("storage");
var dataLake = storage.AddDataLake("data-lake");
var fileSystem = storage.AddDataLakeFileSystem("data-lake-file-system");

api.WithReference(dataLake)
   .WaitFor(dataLake)
   .WithReference(fileSystem)
   .WaitFor(fileSystem);

builder.AddAzureDataLakeServiceClient("data-lake");
builder.AddAzureDataLakeFileSystemClient("data-lake-file-system");

For more details, see Azure Data Lake Storage.

Database integrations

MongoDB: Connection string options now correctly prepend forward slash
MongoDB Entity Framework Core: New client integration Aspire.MongoDB.EntityFrameworkCore
Oracle EF Core: Multi-targeting support added
SQL Server: New Aspire.Hosting.SqlServer exports

The new MongoDB EF Core provider makes it easier to use EF Core with MongoDB while keeping the normal Aspire enrichment experience:

builder.AddMongoDbContext<MyDbContext>("mongodb", databaseName: "appdb");

If you register the DbContext yourself, you can still opt into Aspire instrumentation and health features with EnrichMongoDbContext<TContext>().

JavaScript hosting with Bun

JavaScript resources can now opt into Bun as their package manager with WithBun(). Aspire configures the right package-manager annotations, install behavior, and container build image defaults for Bun-backed applications.

var builder = DistributedApplication.CreateBuilder(args);

builder.AddViteApp("frontend", "./frontend")
    .WithBun()
    .WithDockerfileBaseImage(buildImage: "oven/bun:latest");

builder.Build().Run();

For more details, see the Bun integration docs.

Emulator updates

Azure ServiceBus emulator updated to 2.0.0
Azure App Configuration emulator updated to 1.0.2
CosmosDB preview emulator readiness check added
Azure Managed Redis now uses rediss:// as the default scheme

AI model updates

AI Foundry models automatically updated
GitHub models updated
AI model code generation now converts markdown to C# XML docs

🚀 Deployment and publishing

Kubernetes improvements

YAML publishing fixes for Kubernetes deployments
Better handling of resources with ExcludeFromManifest

Azure deployment

Container Registry exposed from compute environments
Improved handling of environment normalization in Azure App Service
Better error messages for deployment failures
Better waiting for Azure role assignments and private endpoints during provisioning
Markdown support in publish and deploy pipeline summaries
Azure portal links in pipeline summaries for the resource group
Better multi-language export coverage for Azure integrations such as Cosmos DB and AppContainers

Pipeline enhancements

Pipeline summary info displayed after successful completion
Environment name validation in deployment state manager
Deployment directory permissions restricted to current user

🐛 Bug fixes

This release includes numerous bug fixes across all areas:

Fixed DCP path creation for AppHostServer
Fixed dashboard URL port logging for randomized ports
Fixed Windows startup error with AUX reserved device name
Fixed race condition in RabbitMQEventSourceListener
Fixed certificate serial number generation
Fixed resource logger service disposal and memory leaks
Fixed various GenAI tool definition parsing issues
Improved search highlight contrast in CLI interactive prompts
Fixed tooltip for view options button in resource details panel

⚠️ Breaking changes

Consolidated configuration files

Aspire now prefers aspire.config.json over the older split configuration model.

New scaffolds and updated tooling write unified configuration there, and launch profiles that used to live in apphost.run.json are merged into the same file. Legacy files are still read during migration, but if you have custom automation that edits .aspire/settings.json or apphost.run.json directly, plan to move that logic to aspire.config.json.

Resource command rename

Built-in resource commands now use the shorter names start, stop, and restart.

If you scripted command names directly, migrate away from resource-start, resource-stop, and resource-restart:

aspire resource api start
aspire resource api stop
aspire resource api restart

Dashboard telemetry API now opt-in

The standalone dashboard now defaults its HTTP API to off.

If you host the dashboard directly and rely on the API, enable it explicitly by setting ASPIRE_DASHBOARD_API_ENABLED=true or by supplying equivalent configuration:

{
  "Dashboard": {
    "Api": {
      "Enabled": true
    }
  }
}

`BeforeResourceStartedEvent` behavior

The BeforeResourceStartedEvent now only fires when actually starting a resource, not on every state change. Update your event handlers if they rely on the previous behavior.

Connection property suffix

A connection property suffix has been added which may require updates to code that accesses connection properties directly.

AIFoundry to Foundry transition

Aspire.Hosting.Azure.AIFoundry was replaced by the broader Aspire.Hosting.Foundry surface.

If you were using the older API, migrate from AddAzureAIFoundry() to AddFoundry() and then attach one or more deployments explicitly:

// Before
var ai = builder.AddAzureAIFoundry("ai");

// After
var foundry = builder.AddFoundry("ai");
var chat = foundry.AddDeployment("chat", FoundryModel.OpenAI.Gpt5Mini);

This aligns the hosting API with the current Foundry branding and unlocks the new deployment and hosted-agent capabilities added in 13.2.

`WithSecretBuildArg` renamed to `WithBuildSecret`

The container build secret API was renamed for clarity:

// Before
builder.AddContainer("worker", "contoso/worker")
    .WithDockerfile("../worker")
    .WithSecretBuildArg("ACCESS_TOKEN", accessToken);

// After
builder.AddContainer("worker", "contoso/worker")
    .WithDockerfile("../worker")
    .WithBuildSecret("ACCESS_TOKEN", accessToken);

If you only used the old name through shared helpers or extension methods, this is usually a straightforward rename.

`IAzureContainerRegistry` obsolete

The IAzureContainerRegistry interface has been marked as obsolete. Use the new ContainerRegistry property on compute environments instead.

Default Azure credential behavior in client integrations

Aspire Azure client integrations no longer use the parameterless DefaultAzureCredential constructor. This is a breaking change for anyone depending on credentials other than ManagedIdentityCredential working in an Azure service. For more information on the new behavior, see Default Azure credential.

Upgrade today

Follow the directions in Upgrade to Aspire 13.2 to move forward and start using the new CLI, TypeScript AppHost, dashboard, hosting, and integration capabilities in this release.

For a complete list of issues addressed in this release, see the Aspire 13.2 milestone on GitHub.