Every team now has someone who can build a small app in an afternoon. A tracker, a request form, a dashboard that pulls numbers from a spreadsheet. The building got easy. The hard part starts the moment that app needs a real audience, real company data, and an IT team willing to let it live.
Copilot Managed Runtime is Microsoft answer to that second problem. It is a hosting service for internal apps, run by Microsoft inside an organization Microsoft 365 tenant. Microsoft introduced it in public preview in September 2026, and at Ignite on November 17, 2026 the company announced that it is generally available and beginning to roll out to tenants.
Copilot Managed Runtime
Official siteA Microsoft operated host for internal apps built with AI tools. Primary use case: taking a small app built in Copilot Code, Cowork, Copilot Studio, or a third party builder and running it for colleagues under the same identity, data policies, and admin oversight as the rest of the tenant.
Key features: Microsoft managed hosting and execution with no cloud services to configure; Entra identity, sharing, and access; governed connections to organizational data and services; organizational policies that govern connector, data, and endpoint access; policy enforcement and audit logging; app inventory and monitoring in the Microsoft 365 admin center; and code that stays editable and Git backed after publishing.
Advantages: the tool used to build an app no longer decides how that app is run or governed; makers keep their build tool and IT keeps one control point. Limitations: apps are internal and need a work sign in; running costs depend on licence coverage or credit limits set by admins; and several of the newest pieces, including Fabric storage and Code Agents, are still in preview.
What the runtime actually does
Think of the runtime as the floor an app stands on, rather than the tool that built it. Microsoft operates the platform. Hosting, scaling, and availability are handled by Microsoft, with no cloud services for the maker to configure, per the Ignite announcement.
When an app is published to the runtime, it runs inside the organization own Microsoft environment. Colleagues open it after signing in with Entra, the identity system Microsoft 365 already uses. Sharing follows that same identity, so putting an app in front of a team looks more like sharing a document than deploying a website.
Data access is governed, not open. The app reaches organizational data and services through governed connections, within boundaries set by IT. Organizational policies govern connector access, data access, and endpoint access, and audit logging sits alongside those controls. That is the whole pitch in one line: the app can touch company data, but only through doors IT already approved.
Build where you want, run in one place
Makers can start in Copilot Code, Copilot Cowork, Copilot Studio, GitHub Copilot, or VS Code. Third party development platforms and tools can publish to the runtime as well. Microsoft named Manus in the Ignite post, and Lovable documents its own route for publishing an app built there into a company tenant.
That openness matters because it separates two choices that used to be glued together. A team can let a business user build in Cowork, let a developer build in VS Code, and let another team use a third party builder, and all three apps still land on one operating foundation. IT does not need a separate inventory and a separate policy story for each authoring tool.
The code also stays a normal project after it ships. Microsoft says the code stays editable and Git backed regardless of the entry point, so makers can keep iterating while the published app stays live and promote changes when they are ready. Organizations using GitHub Enterprise can connect their own repositories, so apps follow the same branching, review, and release practices as the rest of their software. Anyone who has watched a no code app become a black box will feel the weight of that detail.
Our coverage of Office moving inside the Copilot app shows the same direction from the other side: Microsoft keeps pulling the place where work is made and the place where work runs closer together.
One inventory for every published app, whichever tool built it. Illustration: Dirty Static
What IT gets, and why IT asked for it
App inventory and monitoring in the Microsoft 365 admin center give administrators a central view of the apps teams have published. Microsoft frames that view as a way to oversee apps created through different tools without organizing the inventory around each authoring experience.
That sounds like admin furniture, and it is, but it answers a real fear. When anyone can generate an app, the risk is not one bad app. The risk is two hundred small apps nobody counted, each holding a connection to data nobody reviewed. A central inventory does not fix judgment, but it makes the fleet visible, and visible is where governance starts.
What arrived with general availability
The Ignite announcement added three pieces on top of the core host, and each one fills a gap makers would have hit fast.
First, storage. Some apps need to keep data of their own, such as the owners, dates, and status updates behind a team launch tracker. A frontier public preview of Microsoft Fabric integration adds an option for persistent app storage and backend capabilities for those records. It sits alongside existing connectivity with SharePoint and Dataverse, so a team can choose a data layer when an app needs one.
Second, local development for agents. Dev tooling now in public preview lets users build custom Copilot Studio agents and workflows locally, change them with their developer tool of choice, and publish to Copilot Studio using the CLI. A developer can keep changes in source control and push the updated project back, keeping the agent and its workflows together.
Third, agents written in code. Code Agents, in early access preview, are custom agents created and hosted on Copilot Managed Runtime, with a choice of model, orchestrator, or harness within the supported scope of the preview. Microsoft provides hosting, Entra identity, channels, monitoring, and lifecycle management for those agents. Sign up is required and acceptance is not automatic.
What running an app costs
Building and running are billed separately, and that split is where most confusion will live. The Microsoft Learn licensing page lays it out plainly, checked on November 18, 2026.
| Activity | What is required | Where billing is managed |
|---|---|---|
| Build in Cowork | A Microsoft Copilot licence and Copilot Credits through the maker Cowork spending policy | Microsoft 365 admin center |
| Build in Copilot Code | A Microsoft Copilot licence, plus Copilot Credits through a spending policy that includes Copilot Code | Microsoft 365 admin center |
| Build in Copilot Studio | Copilot Credits through Copilot Studio billing for the environment | Power Platform admin center or Microsoft 365 admin center |
| Build with the runtime CLI | No licence required to create, build, or deploy | Not applicable |
| Run an app, wherever it was built | A Power Apps Premium licence or Copilot Credits through a spending policy that includes Copilot Managed Runtime | Microsoft 365 admin center |
Running is measured in API calls. Launching an app, calling data through a connector, calling native data sources such as Dataverse, and publishing an app each count, at 0.1 Copilot Credits per call, so one credit covers ten calls. Microsoft Learn example for a broad starting policy is 100 credits per user per month, listed as US$1, which covers about 1,000 API calls. Apps that use specialized services, such as Work IQ APIs, are charged separately at their own rates.
Two traps deserve plain words. A Microsoft 365 Copilot licence on its own does not cover running these apps, and the Power Apps use rights included with Microsoft 365 or Dynamics 365 do not cover them either, per Microsoft Learn. Sharing an app also does not pay for it: each person running the app needs their own Premium licence or coverage in a spending policy, plus permissions for the data underneath.
What Works
- One governed host for apps built in many tools, including third party builders
- Microsoft runs hosting, scaling, and availability, with no cloud setup for makers
- Entra sign in, governed data access, policy enforcement, and audit logging built in
- Central app inventory and monitoring in the Microsoft 365 admin center
- Code stays editable and Git backed, with GitHub Enterprise repositories supported
What Does Not
- Internal only by design, with a work sign in required and no public audience
- Running an app needs a Premium licence or credit coverage for every user, not just the maker
- Building and running bills arrive through different policies and different admin centers
- Fabric storage, local agent tooling, and Code Agents are still previews
Which should you choose
Choose Copilot Managed Runtime if your organization already lives in Microsoft 365 and small internal apps are piling up. A tracker built in Cowork, a form built in Copilot Studio, and a tool built by a developer can all run under one identity and policy model, and IT can see all of them in one place. Start with the broad spending policy Microsoft Learn recommends, watch real use for a month, then add higher limits for the groups that need them.
Choose it carefully if your app needs its own data store today. The Fabric integration that gives apps persistent storage is a frontier public preview. SharePoint and Dataverse connectivity already exists, so an app that fits those stores is on firmer ground than one planned around a preview backend.
Look elsewhere if the app is public facing. This runtime is built for colleagues inside a tenant, signed in with a work account. A customer facing site or a public tool belongs on a public host, not on a governed internal floor. Look elsewhere, too, if your organization runs its apps outside the Microsoft 365 world and has no wish to bring identity, billing, and admin work into that tenant.
The closest comparison on this site is Microsoft putting Office inside the Copilot app: in both cases, the product news is really about location. Work moves to where the identity and the data already are.
Final thoughts
The interesting move here is not that Microsoft can host an app. It is that Microsoft decided the build tool should stop mattering at the moment an app starts doing real work. Cowork, Copilot Studio, VS Code, and a third party builder all end at the same door, with the same sign in, the same data rules, and the same inventory.
That is a sensible answer to the app sprawl AI building is about to cause, and general availability makes it an answer tenants can actually plan around. The open questions are the usual honest ones: how credit costs feel once a popular app meets a whole department, and how fast the preview pieces grow up. For a Microsoft 365 shop drowning in small useful apps, though, a governed floor beats a pile of clever orphans every time.
Sources
- General availability, build paths, Fabric preview, dev tooling preview, and Code Agents: Copilot Managed Runtime is now generally available, Microsoft Tech Community, November 17, 2026
- Licensing, spending policies, credit rates, and cost examples: Manage licensing and Copilot Credits for apps on Copilot Managed Runtime, Microsoft Learn
- Publishing a third party built app into a tenant, and internal access rules: Build and publish apps to Microsoft Copilot Managed Runtime, Lovable Docs
- Body illustration: Dirty Static
END OF TRANSMISSION
Stay curious. Question everything.


