Bring specialized model behaviors to applications without provisioning separate compute for every adapter.
We're introducing Multi-LoRA adapter deployment on Managed Compute in Microsoft Foundry, now in preview. Multi-LoRA lets you deploy multiple compatible fine-tuned LoRA adapters on a shared base-model deployment, so you can serve specialized model experiences without provisioning separate compute for each adapter.
The preview initially supports Muse-Glimmer-30B, Qwen3.8-27B, Qwen3.6-35B-A3B, and GPT-OSS-120B.
Managed Compute is Microsoft Foundry’s managed platform for deploying and serving open models on dedicated GPU capacity. Foundry manages the underlying infrastructure and serving runtime, so teams can focus on their models and applications rather than operating GPU infrastructure. Multi-LoRA builds on this foundation, allowing compatible adapters for supported base models to share a base-model deployment. Learn more in the Managed Compute announcement and Managed Compute overview.
This brings the output of Foundry fine-tuning closer to the applications that use it. Whether you're building a support assistant or adapting a model to financial terminology and reporting formats, you can move from a registered adapter to a callable deployment while reusing the serving foundation already in place.
Specialization without a separate serving stack
Fine-tuning gives teams a way to shape a model for different tasks. The operational challenge comes afterward: serving each specialization without treating it as another infrastructure project. A separate deployment of every model variant can mean repeating the common base model's serving setup, even when the variants share the same foundation.
Multi-LoRA separates the identity of a specialization from ownership of the compute underneath it. Platform teams manage the shared target deployment; application teams select the adapter that fits their task. The benefit is a simpler serving arrangement for compatible specializations, not a new infrastructure stack for each one.
- Keep specialized behaviors distinct. Each adapter deployment has its own name, making the application's choice explicit.
- Reuse the serving foundation. Compatible adapters share the target's base model and compute rather than provisioning accelerators of their own.
- Keep application calls familiar. Select an adapter through the Foundry account's chat-completions endpoint using its deployment name.
One base model, multiple adapter deployments
A LoRA adapter contains a lightweight set of learned weight updates that specializes a compatible base model. The adapter doesn't run independently. A Managed Compute target hosts the base model and serving capacity, while individual adapter deployments connect registered fine-tuning outputs to that target.
For example, suppose you fine-tune the same Qwen base model and version for two scenarios: customer support and finance.
You could deploy both adapters against a shared target deployment qwen-prod:
- qwen-prod: the shared Managed Compute deployment hosting the base model and LoRA-capable serving runtime.
- qwen-support: an adapter deployment referencing the registered support fine-tuning output and targeting qwen-prod.
- qwen-finance: an adapter deployment referencing the registered finance fine-tuning output and targeting qwen-prod.
Applications invoke qwen-support or qwen-finance through the respective adapter deployment’s inference route. The service resolves the shared parent internally; applications do not select an adapter by changing requests to the existing qwen-prod base-model route.
Each adapter deployment can be replaced with a newer registered output or deleted independently. This independence does not mean dedicated compute or isolated serving capacity: both adapters use qwen-prod’s shared resources.
The shared deployment must use the compatible base-model version and a deployment template and runtime that support LoRA. Matching the base-model name alone is insufficient—the service also validates adapter compatibility and available adapter capacity.
From fine-tuning to deployment in the portal
The Foundry portal connects a registered fine-tuning output to the compute that will serve it. You can start from Build > Models or a completed fine-tuning job, without leaving the adapter deployment flow to set up a target separately.
- Select your adapter: Start with the registered output from a completed Foundry fine-tuning job and begin a LoRA-enabled Managed Compute deployment.
- Choose compatible target deployment. Reuse an existing LoRA-enabled target deployment or create a new LoRA-enabled target deployment in the same flow.
- Name and deploy the adapter. Once it's ready, open its details to test the specialized behavior.
To add the finance specialization, deploy its compatible adapter against the same qwen-prod target using the name qwen-finance. The target's details bring the attached adapter deployments together, making the shared-serving arrangement easy to inspect.
Open an adapter in the playground and try a prompt relevant to its task. Select the adapter deployment, rather than only the base-model target, to evaluate the fine-tuned behavior.
Deploy with SDK calls
For automated workflows, you can deploy a registered LoRA adapter to a compatible Managed Compute target using the Python management SDK. The azure-mgmt-cognitiveservices 15.0.0b6 prerelease includes adapter deployment operations.
The example below assumes that you have an authenticated management client named `client`, the required resource identifiers, and an existing compatible target deployment named `qwen-prod`. For the complete deployment flow and prerequisites, see Deploy fine-tuned LoRA adapters to Managed Compute for more details.
Connect the support adapter to the shared target
Use the registered adapter model ID as the source and specify the Managed Compute LoRA-enabled deployment that will serve it as the target.
from azure.mgmt.cognitiveservices.models import (
AdapterDeployment,
AdapterDeploymentProperties,
)
client.adapter_deployments.begin_create_or_update(
resource_group_name=RESOURCE_GROUP,
account_name=ACCOUNT_NAME,
adapter_deployment_name="qwen-support",
resource=AdapterDeployment(
properties=AdapterDeploymentProperties(
source_model_id=SUPPORT_ADAPTER_MODEL_ID,
target_deployment_name="qwen-prod",
)
),
).result()
To deploy another compatible adapter, repeat the operation with its registered model ID and a unique adapter deployment name while keeping `qwen-prod` as the target. Multiple adapters can share the same target deployment and its underlying compute.
Choose the specialization in your application
After the adapter deployment succeeds, use an authenticated OpenAI client configured for your Foundry account endpoint. Set model to the adapter deployment name, rather than the target deployment name, to select the adapter your application should use.
For example, to send a request to the `qwen-support` adapter:
completion = openai_client.chat.completions.create(
model="qwen-support",
messages=[
{"role": "user", "content": "How do I reset my account password?"}
],
)
To invoke another adapter hosted on the same target, simply change the `model` value to that adapter's deployment name. The application can therefore select between specialized adapters while they share the same Managed Compute target.
Pricing and capacity considerations
Before deploying Multi-LoRA, here are a few things to keep in mind:
- Pricing: Adapter deployments have no separate pricing and don’t provision additional compute. Billing applies to the shared Managed Compute target deployment, which is billed hourly based on the accelerators used.
- Capacity: A target deployment can host up to eight adapter deployments. Attached adapters share the target deployment’s serving capacity, and adding an adapter doesn’t create another model instance or increase the target’s capacity.
- Compatibility: Each adapter must match the base model and version running on the target and use a LoRA-enabled deployment template. Adapter count, LoRA rank, and available memory are also subject to the selected template’s limits.
- Adapter source: The preview currently supports LoRA adapters produced through fine-tuning in Foundry. Importing externally trained adapters isn’t yet supported.
For current Managed Compute rates and additional details on billing, quota, and limits, see the Managed Compute overview and Adapter deployment overview.
Get started
Ready to try Multi-LoRA adapter deployment on Managed Compute? Start with your Foundry fine-tuning outputs and deploy compatible LoRA adapters to a shared target deployment.
Explore the Microsoft Foundry fine-tuning cookbook for fine-tuning examples, recipes, and sample datasets. Then, review the Adapter deployment overview to understand how Multi-LoRA serving works, or follow Deploy fine-tuned LoRA adapters to Managed Compute for the complete deployment flow.
Get started with your fine-tuned adapters and bring multiple specializations to a shared Managed Compute deployment in Microsoft Foundry.