DIRTY STATIC / DISPATCH Tools18 NOV 2026 • 11 MIN READ
A concrete hosting platform in a brutalist hall carrying small glowing yellow app windows, with robotic arms placing apps and hazard stripes on the floor
ToolsINTELLIGENCE FOR THE MACHINE AGE

Copilot Managed Runtime: Host Apps Safely

Copilot Managed Runtime is Microsoft operated hosting for the apps people now build with AI tools. This profile covers what the runtime does inside a Microsoft 365 tenant, which build tools can publish to it, how Entra identity and governed data access work, what running an app costs in Copilot Credits, and what arrived with general availability at Ignite on November 17, 2026, including the Fabric storage preview and Code Agents.

Start reading ↓

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 site

A 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.

Platforms
Microsoft 365 tenant; apps open in a browser, with users signing in through Microsoft Entra
Pricing
Running an app needs a Power Apps Premium licence or Copilot Credits through a spending policy, billed at 0.1 credit per API call; building is billed separately by the tool used, and building with the CLI needs no licence

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.

A wall of app tiles and gauges above an operator desk in a concrete control room, with caution yellow warning lights 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.

ActivityWhat is requiredWhere billing is managed
Build in CoworkA Microsoft Copilot licence and Copilot Credits through the maker Cowork spending policyMicrosoft 365 admin center
Build in Copilot CodeA Microsoft Copilot licence, plus Copilot Credits through a spending policy that includes Copilot CodeMicrosoft 365 admin center
Build in Copilot StudioCopilot Credits through Copilot Studio billing for the environmentPower Platform admin center or Microsoft 365 admin center
Build with the runtime CLINo licence required to create, build, or deployNot applicable
Run an app, wherever it was builtA Power Apps Premium licence or Copilot Credits through a spending policy that includes Copilot Managed RuntimeMicrosoft 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

■

END OF TRANSMISSION

Stay curious. Question everything.

CONTINUE THE DESCENT

MORE FROM DIRTY STATIC ↘