Agile InsightsBriefing
A black and white patch panel of cable sockets, four plugged cables ringed in yellow and labelled Approved Connectors, and two loose cable ends crossed out in yellow.

Episode 15 · Primer and discussion · About 14 minutes in two parts

Microsoft governs the access. You still have to govern the answer.

Copilot Code lets anyone in the Frontier preview build an app with A I and share it with colleagues. What Microsoft’s managed runtime governs, what it leaves to the organisation, and the defaults to decide now.

#microsoft#oversight

Part 1: Primer · About 7 minutes

Download the MP3 · Linda and Leonard, AI voices, read a script written from the sources below.

Part 2: Is inherited governance enough? · About 8 minutes

Download the MP3 · Linda and Leonard, AI voices, read a script written from the sources below.

In this episode

01Everyone can now publish softwareCopilot Code builds an app from a plain language description, and Copilot Managed Runtime lets the builder publish and share it with named people or groups, with no deployment step. It is in preview through Frontier.
02The platform governs access wellAs Microsoft documents it, sign in, conditional access and data loss prevention apply, each viewer sees only data they already have rights to, apps are limited to eighteen Microsoft connectors, and every published app has a named owner.
03Access is not assuranceMicrosoft’s own application card says to treat what Copilot Code builds as drafts and test it before relying on it. Nothing in the documentation describes a check on an app’s logic before colleagues rely on its numbers.
04The defaults are decisionsFrontier is off until an administrator opts people in, auto approve is on, the GitHub review path is off, sharing limits are set per environment group, and running an app has its own spending policy.
05What to doDecide the defaults on purpose, extend your A I register to apps your staff build, and give any app shared widely, touching sensitive data or feeding a reported number a named owner, a logic review and a cost owner.
Sources and links (10)
Copilot Code: Make the power of coding accessible to everyone · Read on Microsoft Tech Community
Microsoft’s launch post, 21 October 2026: what Copilot Code is for, the revenue simulator example, and the claim that apps inherit your governance.
Introducing the new Copilot with Home, Code and Autopilot · Read on the Official Microsoft Blog
Microsoft’s announcement, 25 September 2026: the new Copilot, the working app as a new unit of knowledge work, and usage based billing.
Application card: Copilot Code · Read on Microsoft Learn
Microsoft’s responsible A I note: treat the output as drafts, test before you rely on or share it, and the overreliance warning.
Manage Copilot Code for your organization · Read on Microsoft Learn
The admin controls and their defaults, including auto approve, the GitHub connection and organisational data.
Use Copilot Code · Read on Microsoft Learn
Publishing as a separate step, sharing with people or groups, and why sharing an app does not share its data.
Copilot Managed Runtime overview for admins · Read on Microsoft Learn
The central app inventory, separate billing for building and running, and the preview limit on users without credit coverage.
Govern apps in Copilot Managed Runtime at scale · Read on Microsoft Learn
The default environment group, the eighteen first party connectors, blocked actions and the sharing switches.
Manage security and compliance for Copilot Managed Runtime · Read on Microsoft Learn
Why sharing limits are set per environment group, not per app.
Work with GitHub in Copilot Code · Read on Microsoft Learn
The draft pull request path for engineering review, and the admin switch that has to be turned on first.
Get started with the Microsoft Frontier Program · Read on Microsoft Learn
Frontier is off by default; an administrator opts in users or groups.

Written from Microsoft’s own public sources and checked on 23 October 2026. Copilot Code and Copilot Managed Runtime are in preview and Microsoft says the details may change, possibly at Ignite in November. No independent review of real use existed when this was made, and two Microsoft pages disagree on how long a permission grant lasts. Check the original before quoting.

Our fact check · 26 claims: 17 verified, 3 partly right, 1 disputed, 3 unverified, 2 not yet known

Before we record, every claim the hosts make is checked against the sources (this table was last updated 23 October 2026). Confirmed means a primary source or two independent reports; Reported means one party says so; Partly right, Disputed, Unverified and Not yet known mean what they say, and the hosts say so on air. This is the table as we left it.

  1. VerifiedNew Copilot (Home, Code, Autopilot) announced 25 Sep 2026Official Microsoft Blog, 25 Sep 2026
  2. Partly rightCode rolling out through Frontier, late Sep to Oct 2026Microsoft blogs, 25 Sep and 21 Oct 2026; The two posts give different start dates
  3. VerifiedFrontier is off by default (“No access”); admin opts in users or groupsLearn, Frontier get-started (15 Oct 2026)
  4. VerifiedBuilds apps, dashboards, tools, scripts from plain language; no coding neededLearn, overview and FAQ
  5. VerifiedUses Work IQ; org data On for cloud, Off for local by defaultLaunch post; Learn, admin page
  6. VerifiedShares agentic technology with GitHub CopilotMicrosoft blogs; As Microsoft’s statement
  7. VerifiedWorking app as a new “unit of knowledge work”Microsoft blogs; As framing, not evidence
  8. VerifiedShared apps run on Copilot Managed Runtime; publishing is a separate explicit stepLaunch post; Learn, use and runtime pages
  9. Partly right“Anyone in the organization with permission to the underlying data can use the app”Launch post; Access is sharing and data permission
  10. Verified“Sharing an app doesn’t share its underlying data”Learn, use page (20 Oct 2026)
  11. Partly rightApp “inherits the governance, security, and management controls” already configuredLaunch post; Learn, runtime pages; Identity and data controls apply, but the runtime adds new settings and defaults to own
  12. VerifiedDefault policy: 18 Microsoft connectors, 12 MCP servers; HTTP, Office Scripts, freeform DAX blockedLearn, runtime governance (29 Sep 2026)
  13. VerifiedSharing limits are set per environment group, not per appLearn, security and compliance (19 Oct 2026)
  14. UnverifiedOrg-wide sharing on or off by defaultLearn, runtime governance; Toggles listed, defaults not stated
  15. VerifiedCentral inventory of runtime apps with a named ownerLearn, runtime overview; Microsoft blog; Cloud-published apps only
  16. Not yet knownWhat happens to an app when its owner leaves—
  17. UnverifiedAdmins can audit Copilot Code actionsLearn, overview; Stated, no audit section or Purview record type documented
  18. VerifiedTreat output as drafts; test before relying or sharing; not for guaranteed accuracy without reviewLearn, application card (6 Oct 2026)
  19. VerifiedOverreliance warning: mistakes “may be hard to detect”Learn, application card
  20. UnverifiedNo documented review of an app’s logic before others rely on itLearn pages (absence); Inference from absence
  21. VerifiedGitHub draft pull request path exists; GitHub connection Off by defaultLaunch post; Learn, GitHub and admin pages
  22. Verified“Auto-approve” of the agent’s permission requests is On by defaultLearn, admin page (15 Oct 2026)
  23. DisputedConsent persists across conversationsLearn overview vs application card; The two pages disagree
  24. VerifiedCode is billed by usage (Copilot Credits); running has its own spending policyMicrosoft blog; Learn, admin and runtime pages
  25. VerifiedPreview: uncovered users warned, then blocked after 20 operations or five minutesLearn, runtime overview (13 Oct 2026)
  26. Not yet knownPrice per credit; cost of a typical shared app—

Want to know more?

Sign up for our podcast at agile-insights.com.au.

Read the transcript · Part 1: Primer

Linda Here is the idea for today. Your staff can now build apps with A I. Microsoft's platform governs who can open them, and what data they reach. But nothing in it checks whether the app's answer is right. That job stays with you. By the end you will know what Copilot Code is, and what its managed runtime governs. You will know what it leaves to the organisation, and the first decisions to make.

Leonard Some context first, because most people have not seen this yet. On the twenty fifth of September, Microsoft announced a new Copilot with three parts, called Home, Code and Autopilot. Copilot Code is a tab in the Copilot app. You describe what you want in plain language, and it builds it. That might be an app, a dashboard, an internal tool or a script. Microsoft's documentation says you don't need to know how to code. It is rolling out through Microsoft's early access program, called Frontier, and it is still a preview. Microsoft's own example is a business leader building a revenue simulator over Power B I data.

Linda Let me build it up in four steps. Step one is an old idea called citizen development. People outside I T have always built tools for their own work. Think of spreadsheets, Access databases and Power Apps.

Leonard The famous shared drive.

Linda Exactly. Finance teams already keep controls over important spreadsheets for exactly that reason. What changes now is who writes the logic. Before, the builder wrote every formula. Now the A I writes it, using your mail, meetings, documents and data to fill in what you didn't say. The builder may never read the code at all.

Leonard That's the part that would worry a finance director. If I build something for myself and it's wrong, I'm the one who pays for it. At some point it stops being my private tool. When does it become something other people depend on?

Linda That is step two, which Microsoft calls Copilot Managed Runtime. A project can run on your own device, or in a cloud that Microsoft manages. To share it, you publish it to that cloud, as a separate and deliberate step. There is no deployment and no server to set up. You share it with named people or groups, and choose whether they can use it or edit it. So everyone in the program can now publish software to colleagues. Microsoft calls the working app a new unit of knowledge work, beside the document and the spreadsheet.

Leonard So who is minding the shop once it's shared? Microsoft's launch post says the app inherits the governance your organisation has already configured. What does that actually cover?

Linda Step three, and credit where it is due, because it covers a lot. People sign in with their normal work identity, and your conditional access and data loss prevention rules apply. Sharing an app does not share its data. Each viewer sees only what they already have rights to. By default, apps may use eighteen Microsoft connectors, such as SharePoint, Outlook and Power B I. Open ended web requests and freeform data queries are blocked. And every published app lands in a central inventory in the admin centre, with a named owner. That answers the oldest shadow I T fear, which is not knowing what exists.

Leonard That sounds better than most of what we had with spreadsheets. If identity, data and inventory are handled, it's tempting to say the job is done. So what is left for the organisation to do?

Linda Step four is the part the platform does not do. Microsoft's own application card for Copilot Code says what it builds should be treated as drafts. It says to test before you rely on it, share it, or use it in production. It says Copilot Code isn't intended for uses that need guaranteed accuracy without human review. And it warns that people accept wrong outputs mainly because mistakes may be hard to detect.

Leonard Which is rather the point.

Linda It is. Nothing in the documentation describes a check on an app's logic before colleagues rely on its numbers. Permissions decide who sees the answer. They do not decide whether the answer is right.

Leonard So take that revenue simulator. One leader builds it, and a whole region starts planning from it. Every person sees only their own data, so the access is perfect...

Linda Perfectly controlled access... to whatever the formula says.

Leonard Right. But if a formula counts a discount twice, the whole region plans on a wrong number. That's a decision support tool, whoever's data it reads. Is there any review path built in at all?

Linda There is one. A builder can connect the project to GitHub and open a draft pull request, so engineers can review the code. But that connection is off by default. An administrator has to turn it on, and even then using it is optional. So here is the common misunderstanding. People hear that the app inherits their governance, and think the question is answered. It is answered for access. Assurance is a different question. It asks whether this is right, and who is accountable if it isn't. The platform handles the first question. The second needs an owner, a review that fits the stakes, and a record of who relies on the output.

Linda That is what this means for A I governance. Shadow A I has moved on a step. The unapproved thing is no longer a chatbot someone used. It is software colleagues depend on. So here is what to do. First, extend your A I register to cover apps your people build. Use Microsoft's inventory as a source, not a substitute. Second, write a simple tier rule. Some apps are used beyond the builder's team, touch financial or customer data, or feed a reported number. Those get a named owner and a review of their logic. Third, decide your defaults on purpose, before the rollout decides them for you.

Leonard That's Part 1. In Part 2, we take those defaults one by one, and ask whether inherited governance is enough. Stay with us.

Read the transcript · Part 2: Is inherited governance enough?

Linda Here is the idea for Part 2. Microsoft governs the access to an app your staff built with A I. You still have to govern the answer. Today we test whether that is a fair reading, or whether the platform's governance is enough. By the end you will have the defaults to decide and the questions nobody can answer yet. You will also have a short list of what to do.

Leonard A quick recap, in case you missed Part 1. Copilot Code is a tab in Microsoft's Copilot app that builds working apps from plain language. A builder publishes an app to Copilot Managed Runtime, Microsoft's hosting layer, and shares it with people or groups. Each viewer sees only data they already have rights to. Microsoft's own application card says to treat the output as a draft, and test it before relying on it. It is all in preview, rolling out through the Frontier program since late September and October.

Linda Here is the question a governance lead will hear first from their executive. If Copilot Code inherits our governance, is there anything left for us to do? There are two honest answers. One says the platform has done most of the work, so keep anything you add light. The other says the platform has done the access work, and the part that matters most is still yours. Leonard has been reading the documentation with the first view in mind, so he can make that case.

Leonard The case for the platform is stronger than people expect. Think about what shadow I T used to look like. Spreadsheets sat on shared drives, nobody knew they existed, and they often held data their users shouldn't see. Here, every published app sits in an inventory with a named owner. Each viewer gets only the data they already have. A default policy limits apps to Microsoft's own connectors and blocks open ended web requests. And nothing happens at all until an administrator opts people into Frontier, because it is off by default. Add a heavy approval process on top, and people go back to the spreadsheets you can't see.

Linda I agree with every fact in that, and I still land somewhere else. Inherited permissions are not inherited correctness. Microsoft's application card says the output should be treated as drafts. It says Copilot Code isn't meant for work that needs guaranteed accuracy without human review. Nothing in the documentation describes a review of an app's logic before others rely on it. The only built in review is a GitHub draft pull request. That is off until I T enables it, and optional after that. So the platform knows the app exists and who owns it. It doesn't know that a region is planning its quarter on it.

Leonard That's fair, and I'll concede the main point. Access control and assurance are different jobs. But I'd hold on to one thing from my side. The answer can't be to review everything. Most of these apps will be personal tools, like a tidy dashboard for one person's week. Reviewing all of those would bury the review team, and teach people to go around it. So the real work is deciding which apps need the review.

Linda Agreed, and that's where we meet. What you add should be a tier rule, not a gate on every app. An app moves up a tier when it's used beyond the builder's team. The same goes for touching financial or customer data, or feeding a reported number. At that point it needs a named owner who answers for the logic. It needs a review that fits the stakes, and a record of who relies on it. Below that line, the platform's controls may well be enough. That keeps the light touch you want, and puts the effort where a wrong number does damage.

Leonard The second thing that struck me in the documentation is how many defaults there are. Every one of them is a decision someone makes, either on purpose or by leaving it alone. Frontier itself is off until an administrator opts people in, which is the safe way round. But the auto approve policy is on by default.

Linda On by default?

Leonard On by default. It lets users have Copilot approve its own permission requests, instead of confirming each action. The GitHub connection is off, so the review path doesn't exist until someone turns it on. And the default environment group is scoped to everyone.

Linda And two more that catch people. Sharing limits are set per group of environments, not per app. So in the preview, you can't natively say this finance model may go to the whole region, and that one may not. Then there's cost. Copilot Code runs on usage based billing, in Copilot Credits, not inside the flat licence. Building and running are billed separately, and running has its own spending policy. In the preview, someone not covered by that policy is warned, then blocked after twenty app operations or five minutes. So a widely shared app can simply stop working for people outside the policy.

Leonard Which is one way to find out who relies on it.

Linda Not the way I'd choose.

Leonard Let's be clear about what isn't known, because it's a fair amount. The documentation doesn't say what happens to an app when its owner leaves the organisation. It lists switches for sharing with the whole organisation and with guests. It doesn't say whether they start on or off. The overview says admins can audit Copilot Code's actions, but no audit section or record type is documented yet. Two of Microsoft's own pages disagree on whether a permission grant lasts beyond one conversation. We don't know what a typical app costs to run. And no independent review of real use exists yet.

Linda So here is where the evidence settles. It's solid on what the platform does, as Microsoft documents it in preview. Identity, data permissions, the connector limits, the inventory and the defaults are all written down. It's also clear on Microsoft's own limit, which is to treat the output as a draft. What it doesn't settle is how this behaves in a real organisation, at scale, over a year. Microsoft Ignite runs from the seventeenth to the twentieth of November, and any of this could change...

Leonard So check the date on anything you quote.

Linda Always. The fair reading today is that the launch post sells the possibility, and the application card states the limit. Your organisation lives between the two.

Leonard So here is what to do, in order. First, decide the defaults on purpose. That means who gets Frontier, whether auto approve stays on, and whether whole organisation and guest sharing are allowed. It also means whether to turn on GitHub, so the review path exists. Second, extend your A I register to cover apps your staff build, fed by Microsoft's inventory. Third, write the tier rule. Anything shared widely, touching sensitive data or feeding a reported number gets a named owner and a logic review. Fourth, give every shared app a cost owner. And ask Microsoft what happens to an app when its owner leaves.

Linda If you'd like to know more, sign up for our podcast at agile-insights.com.au.

Leonard Thanks for listening.

More on #microsoft

Episode 20 · Primer and discussionUsage is not quality: who reads the feedback?Episode 25 · Primer and discussionThe managed loop: what you still own when the vendor runs your agent.Episode 22 · Primer and discussionFrom Pilots to Programs: govern an agent by what it does.Episode 17 · Primer and discussionSwitching on a role pack is a process decision, not an I T toggle.Episode 10 · Primer and discussionMicrosoft now ships the controls for AI agents. The decisions are still yours.Reference 6 · PrimerMicrosoft Agent Governance Toolkit: runtime control for AI agents

Every episode tagged #microsoft

All of the briefings (38) · Follow Briefing in Apple Podcasts or any podcast app

Everything from Agile Insights: briefings, Making You Think and the reference series