Microsoft is moving Copilot beyond generating answers and code into operating the software that AI helps people create. Copilot Managed Runtime, now in public preview, provides a Microsoft-hosted execution environment inside the Microsoft 365 tenant boundary, giving apps built with Copilot a shared layer for identity, governed data access, deployment, versioning, monitoring and lifecycle management.
The company introduced the platform in a September 25 Copilot announcement, alongside the broader redesign of Microsoft Copilot. Managed Runtime already powers applications created in Copilot Cowork, the new Copilot Code experience and Microsoft Copilot Studio. Microsoft is also opening the host to professional developers and third-party development tools through an SDK, CLI and plugin model.
Generating an app is no longer the end of the AI workflow
Generative coding tools have dramatically reduced the effort required to produce functioning software, but enterprise deployment remains a separate problem. An application still needs somewhere to run, an identity model, access controls, approved data connections, deployment processes, monitoring and a lifecycle that IT can govern. Microsoft’s Managed Runtime is designed to make that operational layer part of the AI application platform rather than a separate infrastructure project.
Microsoft describes the host as a shared enterprise foundation around applications. Instead of every team provisioning its own cloud resources and assembling a different governance stack, code can be deployed into a Microsoft-operated environment that inherits organizational controls. The organization defines the boundaries; Microsoft operates the platform; builders retain the ability to create in different tools.
This changes the meaning of Copilot Code and Cowork. They are not only interfaces for producing artifacts or snippets. Their output can become running software inside the same enterprise environment from which the work originated.
Entra identity and organizational policy sit underneath every hosted app
The runtime uses Microsoft Entra identity for authorized access and sharing. Organizational policies can govern the connectors, enterprise data and endpoints an application is allowed to use, while auditing provides a record of activity. That makes identity and policy properties of the hosting layer rather than requirements every individual AI-generated application must reinvent.
This distinction is important as application creation expands beyond professional developers. A business user can increasingly describe an internal tool in natural language, while IT still needs to answer conventional security questions: who can run it, which information can it reach, which external services can it contact and whether its behavior remains compliant with organizational policy.
Managed Runtime attempts to separate those responsibilities. Builders can work in the environment suited to them, while administrators retain a common control plane over execution. Microsoft’s phrase for this architecture is effectively open building with a managed run layer.
Enterprise knowledge becomes executable context
The deeper implication is that organizational knowledge is no longer used only to ground an AI answer. Through connectors, Work IQ and governed data access, applications running in Managed Runtime can work with enterprise information as part of their execution. The knowledge layer becomes something software can act on rather than merely summarize.
That is a meaningful step beyond retrieval-augmented generation. In a classic enterprise RAG workflow, a model retrieves internal documents and uses them to answer a question. A governed application can use authorized enterprise context as part of a workflow, interface or business process that persists beyond one response. The output is not necessarily another paragraph of generated text; it can be a functioning internal application.
This follows the same architectural direction NetContentSEO recently examined in our analysis of persistent enterprise context: the useful knowledge layer increasingly sits outside the model itself and is retrieved through governed systems when needed. Managed Runtime adds an execution environment around that context.
Git-backed versioning turns AI-created software into maintainable software
Microsoft is also trying to prevent AI-created applications from becoming disposable black boxes. The runtime supports automatic version and source control through Git, while the SDK and CLI let developers scaffold projects, configure data connections, generate typed connector services, preview applications, deploy them and create new versions through the same toolchain.
Teams can work on a new version while the existing application remains available to users. Professional developers can pull down editable code and continue working with familiar web technologies instead of forking the AI-generated result into an entirely separate engineering environment. That creates a bridge between natural-language application creation and conventional software development rather than forcing organizations to choose one or the other.
The distinction matters because enterprise software rarely stops evolving after its first successful generation. Requirements change, integrations break, policies evolve and users discover new needs. Versioning and source control make the generated app part of a maintainable lifecycle.
The Microsoft 365 admin center becomes the inventory for AI-created apps
Applications hosted through Managed Runtime appear in the new Apps experience in the Microsoft 365 admin center. Administrators can review access, usage, health and policy from a centralized inventory, regardless of whether the application originated in Cowork, Code, Copilot Studio or an SDK-compatible external development tool.
This centralized inventory addresses one of the most predictable risks of AI-assisted app creation: software proliferation. If building an internal application becomes dramatically easier, organizations can quickly accumulate hundreds or thousands of small tools. Without a common inventory, IT can lose visibility into who owns them, which data they touch, whether anyone still uses them and whether they remain healthy.
Microsoft’s model makes monitoring part of the runtime itself. Usage and app-health visibility give administrators a way to evaluate what has been deployed rather than discovering AI-created applications only when something fails or a security review begins.
Third-party builders can target the same governed runtime
Managed Runtime is not restricted to Microsoft’s own authoring interfaces. The SDK acts as a connective layer between development tools and the host, allowing third-party and professional-development experiences to deploy applications into the same managed Microsoft 365 environment. Microsoft specifically says developers can use the SDK and plugins to build applications for the host.
This creates an important platform effect. A company can allow teams to build with different AI coding tools without necessarily accepting a different deployment and governance architecture for each one. The creation layer can remain diverse while the runtime layer becomes standardized.
Microsoft cites Lovable as an example of that model: applications created in an external development experience can be deployed inside the customer’s Microsoft tenant and inherit the same sign-in, policies and application inventory. The strategic point is broader than any one partner. Microsoft is positioning the runtime as a destination for AI-created enterprise software regardless of which compatible tool generated the code.
Copilot is becoming a software platform, not just an assistant
The Managed Runtime launch makes more sense when viewed alongside Microsoft’s other September 25 Copilot announcements. Code lets users create applications and workflows from natural language. Autopilot introduces persistent agents that can continue working over time. A unified plugin registry creates a shared discovery layer for capabilities. Managed Runtime supplies the governed infrastructure where generated applications can actually execute.
Together, those components shift Copilot from an answer interface toward an application and agent platform. NetContentSEO recently covered a similar infrastructure shift around OpenAI’s agent platform, where managed sessions, retrieval and tools turn a model API into a broader execution environment. Microsoft’s version is tightly anchored to the enterprise tenant, Microsoft 365 identity and organizational data governance.
Governance becomes part of the AI development stack
The public preview also illustrates how the center of gravity in enterprise AI is changing. Early generative-AI governance focused heavily on which models employees could access and what data could be sent into prompts. AI-created software introduces a wider problem because generated code can persist, connect to systems, expose interfaces and continue operating after the original conversation is over.
That makes runtime policy as important as model policy. An organization needs to control not only what an AI can say, but what generated software can execute, which endpoints it can call and which enterprise information it can use. Entra identity, connector policies, endpoint restrictions, auditing and lifecycle controls are therefore not secondary administration features; they are the mechanisms that allow AI-assisted application creation to scale without every app becoming an independent security architecture.
The enterprise knowledge layer is becoming an execution layer
The most important consequence of Managed Runtime is conceptual. Enterprise AI began by placing a conversational interface over organizational knowledge. Microsoft is now building infrastructure that lets AI-created software run inside that same governed environment, use live organizational context and remain visible to administrators throughout its lifecycle.
The public preview does not eliminate the need for software review, secure design or human oversight, and Microsoft does not claim that every AI-generated application becomes production-ready automatically. What it changes is the default deployment path: hosting, identity, data policy, versioning and monitoring can be provided as a common platform instead of reconstructed for each new application.
As AI lowers the cost of creating software, the scarce resource shifts from writing code toward governing what that code is allowed to do. Copilot Managed Runtime is Microsoft’s attempt to own that next layer. Copilot can generate the application, but Microsoft 365 increasingly becomes the environment that decides how the application lives, what it can know and where it is allowed to act.