Build once, adapt everywhere.
Modern applications increasingly need to run across public clouds, private infrastructure, sovereign environments, and resource-constrained edge locations. However, application code and deployment definitions are often tightly coupled to a specific platform's services, APIs, and operational tooling. Moving an application to a new environment can therefore require significant re-architecture, duplicated platform integration, and separate operational processes. These challenges are especially acute for organizations that must meet data residency and regulatory requirements, operate with limited or intermittent connectivity, or modernize existing applications without rewriting them.
Adaptive Apps address this problem by separating an application's intent and programming model from the environment-specific implementation of its required capabilities. Applications target explicit capability contracts rather than a particular infrastructure stack, allowing each environment to provide those capabilities using the technologies best suited to it. By combining a platform-agnostic application model, portable APIs, consistent capability portfolios, and AI-powered modernization tooling, Adaptive Apps enable applications to move across cloud, edge, and hybrid environments without re-architecture or unnecessary platform lock-in.
-
Enable sovereign, multi-cloud, and isolated edge deployments
Meet regulatory, geopolitical, and operational requirements while maintaining a single application model.
-
Unlock existing investments by modernizing brownfield applications
Extend the life and value of legacy systems by making them portable, adaptable, and future-ready.
-
Bridge AI-native agentic systems with traditional microservices
Create a unified platform where emerging AI-driven workflows and established enterprise services operate together seamlessly.
Adaptive Apps is comprised of four layers: application model, (optional) programming model, platform portfolios and AI-powered tooling. Rather than redefining these concepts from the ground up, Adaptive Apps leverage proven open-source and cloud-native technologies, such as Radius, Dapr, and Azure Arc, and orchestrate them into an end-to-end solution.
The architecture is described in additional detail on Microsoft Learn at Build portable applications with adaptive apps.
Adaptive Apps use Radius as the application model.
A Radius application is composed of multiple resources, where each resource type can be deployed to supported environments using environment-specific recipes. This provides a clean and extensible abstraction for describing platform-agnostic applications.
Radius resource types are extensible, allowing Adaptive Apps to introduce new concepts such as AI agents alongside existing core resource types like compute and storage.
For an application to be truly portable, its code must avoid direct dependencies on platform-specific APIs.
Dapr provides this abstraction through a sidecar model that exposes platform capabilities, such as state management, messaging, and pub/sub, behind stable, portable APIs. Adaptive Apps support Dapr as the preferred programming model for new applications. In addition, Adaptive Apps provide AI-powered refactoring tools to help uplift brownfield applications by incrementally introducing the Dapr programming model.
NOTE: Using Dapr is not mandatory. When sufficient platform parity exists across target environments, applications may bind directly to platform-specific APIs. For example, if all required services are available across Azure and Azure Arc, an application written against Azure APIs can remain portable within that scope.
Adaptive Apps adopt and extend AI-enabled tools to simplify adoption and modernization.
As an initial capability, Adaptive Apps provide AI-based refactoring tools that assist in transforming legacy applications to adopt the Dapr programming model and portability patterns.
Delivering a consistent set of platform capabilities across cloud and edge environments is challenging due to differences in software availability, compatibility, and resource constraints.
To enable predictable portability, Adaptive Apps introduce the concept of a capability portfolio, which is a well-defined set of capabilities that an environment must provide in order to host a Adaptive App.
An application targets a specific capability portfolio and can be deployed to any environment that implements that portfolio.
A horiztonal comparison of portfolios is available here.
As a starting point, we define six portfolios, as summarized in the following table:
| Portfolio | Identity | Service mesh (Istio) | Observability | Governance (OPA) | On-cluster AI (Kaito) |
|---|---|---|---|---|---|
min |
✓ | ✗ | ✗ | ✗ | ✗ |
core |
✓ | ✓ | ✓ | ✗ | ✗ |
ent |
✓ | ✓ | ✓ | ✓ (off by default) | ✗ |
min-ai |
✓ | ✗ | ✗ | ✗ | ✓ |
core-ai |
✓ | ✓ | ✓ | ✗ | ✓ |
ent-ai |
✓ | ✓ | ✓ | ✓ (off by default) | ✓ |
min— baseline hosting (identity + service hosting). Ideal for PoC, MVP, hackathon, demos and experiments.core— builds onminwith operational readiness: service mesh, data sync, observability, basic policy enforcement, secret management. Ideal for standard production workloads.ent— builds oncorefor large-scale enterprise: advanced policy enforcement, advanced certificate management, advanced monitoring, backup/restore.*-ai— layer on-cluster AI model management onto the base portfolio for offline / local inference.
Adaptive Apps don't assume a specific control plane that operates the applications. A capability vendor is free to choose the most appropriate packaging and delivery mechanism to bootstrap a portfolio, including:
- Helm charts for Kubernetes environments
- Azure Arc extensions
- Azure Bicep templates
- Terraform templates
As long as the portfolio satisfies the capability contract, applications remain portable.
Adaptive Apps enable third-party vendors to implement and deliver capability portfolios on cloud, edge, or specialized environments. As long as a portfolio exposes the required capabilities and APIs, any Adaptive App targeting that portfolio can be deployed without modification.
To support the Radius application model, capability vendors are expected to implement the necessary Radius recipes for deployment.
Follow our Getting Started tutorial to deploy an Adaptive App portfolio on local Kubernetes, AKS, Azure Local, or Azure Arc.
- Generate Radius artifacts with the
adaCLI — turn adocker-compose.ymlinto anapp.bicep, comparing thecompose,llm, andskillstrategies and the critic loop. - Governance — author
AuthorizationPolicy(native and OPA-delegated) for theent/ent-aiportfolios. - Service mesh — enroll the app namespace in Istio and verify mesh traffic.
Looking for a guided, hands-on learning path instead of reference material? The Adaptive Apps MicroHack is a challenge-based workshop, hosted in the microsoft/MicroHack repository, that is built directly on top of this project.
It walks platform engineers and application developers through the full lifecycle of an adaptive application: preparing Kubernetes target platforms, installing and operating Radius, authoring resource types and environment-specific recipes, and then proving portability by deploying the Simplified Trading App from this repository — unchanged — to Azure, Azure Local, and a disconnected edge cluster. Later challenges extend the same approach to identity, secure service communication, AI services, and brownfield modernization.
This repository (microsoft/adaptive-apps) |
The MicroHack (microsoft/MicroHack) |
|
|---|---|---|
| Purpose | The Adaptive Apps project itself: the reference architecture, concepts, and shipped assets | A guided, time-boxed workshop that teaches the concepts by doing |
| Content | Capability portfolios, Radius resource types and recipes, Helm charts, the ada CLI, the Simplified Trading App, and task-focused tutorials |
A sequence of challenges with student and coach guides, per-audience learning paths, and a pre-provisionable lab environment |
| How you use it | Consume it as the upstream source — reference it, deploy from it, extend it in your own applications | Work through it once, end to end, to build the skills; it consumes the assets published here rather than redefining them |
| Audience | Anyone building, operating, or extending Adaptive Apps | Platform engineers (challenges 02–06) and application developers (challenges 05–11) new to the approach |
In short: this repository is the product, and the MicroHack is the hands-on course built on it. The MicroHack does not introduce a separate stack — any change to the concepts, portfolios, or recipes originates here.