Microsoft Just Turned Copilot Into an OS for Work - And Autopilot Keeps Going After You Log Off

Short answer: Microsoft rebuilt Copilot as Home, Code and Autopilot — an OS-for-work shell with live Office files, tenant-hosted apps and a persistent agent that keeps going after you log off. Chat stays on seat licences; agentic work uses usage-based billing. If you run Microsoft 365, set identity, audit and spend limits before Autopilot chases work overnight.

Key takeaways:

Home shell: Start in Home so Chat and Cowork share context instead of separate AI hubs.

Code sandbox: Build trackers and apps in natural language only inside Managed Runtime under IT rules.

Autopilot identity: Give each agent a name, role, goal and audit trail before it @mentions people.

Billing split: Keep everyday Chat on USL; put Cowork, Code and Autopilot on metered UBB with caps.

Human gates: Block external sends and customer-facing “done” marks until a person reviews.

Something shifted in how Microsoft talks about Copilot. It is not just a sidebar chat anymore, and it is not only a productivity add-on glued to Word or Teams. Satya Nadella framed the rebuild as Copilot becoming a new OS for work. Jared Spataro, CMO for AI at Work, walked through the same story in the official Microsoft post: three surfaces, one agent platform, and a clear bet that digital teammates will live inside Microsoft 365 with identity, memory, and governance attached.

The rebuilt Copilot app now centers on Home, Code, and Autopilot. Home is where you start, chat, and hand off big jobs. Code lets almost anyone describe an app or workflow in everyday wording and get something tangible back. Autopilot - previously Scout - is the persistent agent that keeps moving when you are offline, asleep, or buried in another meeting.

If that sounds like marketing fog, it can. Dig into the product claims and the picture turns pellucid: Office files that stay live inside Copilot, a Managed Runtime that hosts tenant-sandboxed apps, usage-based billing for the agentic pieces, and agents that show up in Teams like people with names and roles. Here is the tour.

Why Microsoft Is Calling This an OS for Work

Calling Copilot an operating system is a deliberate metaphor. An OS does not just answer questions. It hosts apps, manages identity, routes work, and keeps state across sessions. That is roughly the shape Microsoft is pushing.

Instead of bouncing between a chat pane, a separate agent studio, and a pile of Office windows, the company wants one work surface that can:

• Orient you with recent activity and suggestions
• Handle instant conversation when you need a quick answer
• Delegate multi-step projects end to end
• Stand up custom tools without a full IT ticket queue
• Run a personal agent that does not clock out when you do

None of that replaces Excel or Teams. It wraps them. The pitch is that Copilot becomes the layer people open first, then trails into documents, channels, and custom apps as needed. Whether that sticks depends on rollout quality and how noisy Autopilot feels in live tenants - but the ambition is clearer than the old "chat next to your docs" story.

One mild digression worth keeping: every big platform eventually wants to be the home screen. Microsoft already owns the desktop for a huge chunk of knowledge work. Building Copilot as the work OS is less a brand pivot and more a bet that agents need a first-class shell, not a floating bubble.

Home: Chat and Cowork in One Starting Point

Home is the new front door. It merges Chat and Cowork so you are not choosing between "ask a question" and "run a project" before you even know what you need.

On Home you can review recent activity, skim suggestions, and pick up where you left off. That last part matters more than it sounds. Context loss is the silent tax of AI work: you explain the brief, close the laptop, reopen tomorrow, and re-explain the brief. Home is meant to cut that loop.

Chat stays the instant conversational mode. A rewrite, a quick summary, a gut-check on tone - that is Chat. Cowork is the delegation lane for end-to-end complex work - think an RFP package, a launch kit, a leadership briefing, or a financial close bundle. You are not babysitting every paragraph. You are assigning an outcome.

Coming next on that surface: state what you need and Copilot routes you to Chat, Cowork, or Code. That routing layer is the quiet product detail that makes the OS metaphor less airy. A good shell does not make you pick the right subsystem every time. It notices intent and opens the right lane.

If you have lived through a dozen "unified AI hubs" that still felt like three products duct-taped together, a little skepticism is healthy. The difference here is that Chat and Cowork share the same starting point and the same Office deep integration story, which we will get to in a second.

Office Inside Copilot: Real Files, Live Sync

This is the part that will either feel obvious in six months or still feel ineffable. Microsoft is putting full Word, Excel, and PowerPoint inside the Copilot app. Not screenshots. Not export-only drafts. Real editable Office files - launch briefs, budgets, decks - that stay in sync with the Office apps your teammates already use.

Live team sync and @mention edits are part of the claim. You can poke at a brief inside Copilot, someone else opens the same file in Word, and the work does not fork into two versions that need a peace treaty later. That is the kind of detail enterprise buyers care about when the demo dust settles.

On the specialty side:

• PowerPoint gets on-brand templates so decks look like your company, not like a generic AI theme pack
• Excel offers change explanations and chart recommendations, which helps when a model rearranges a model and you need to know why
• Skills bring specialized expertise into the flow - financial work in Excel, legal drafting support in Word, and similar domain packs

Skills are easy to undersell. A general chat model that "kind of knows finance" is not the same as a skill path tuned for spreadsheet logic and review habits. Whether Skills become the App Store moment for Copilot or a quiet enterprise feature set remains open, but the direction is clear: specialized competence, not one blob that pretends to be every department.

Code: Describe the App, Get the App

Code is the surface aimed at builders who are not always developers - and at developers who still want a faster path from idea to internal tool.

Anyone can describe an app, tracker, dashboard, automation, or workflow in natural language. Copilot builds it. Under the hood it leans on the same technology lineage that powers GitHub Copilot, which is a solid credibility signal for people who already trust that stack for code completion and agentic coding.

Important guardrails in the product story:

• Solutions are sandboxed and tenant-hosted
• Microsoft Copilot Managed Runtime hosts the code safely inside Microsoft 365 under IT governance
• Grounding comes through Microsoft IQ, with plugins that keep data in sync

The reported solution set covers desktop widgets, interactive dashboards, and cloud-hosted internal apps. That covers a lot of the "I need a tracker by Friday and I do not want a three-sprint backlog item" reality of corporate life.

Developers are not being pushed out of the picture. They still use GitHub Copilot, now with more connectivity into the broader Copilot platform. The framing is complementary: citizen builders get Code for operational tools; pros keep their deeper workflows and gain hooks into the same agent fabric.

There is a cultural win buried here if IT plays it well. A lot of shadow IT exists because waiting for a formal app feels slower than a spreadsheet glued to email. Code plus Managed Runtime is Microsoft’s answer: let people build, keep it inside the tenant, and give security a place to stand. That only works if the sandbox is real and the plugin story does not feel like duct tape.

Availability-wise, Code moves through the Frontier program first, then broader access, with preview for Microsoft 365 Premium and Pro later. Managed Runtime is already in preview. The same foundation is meant to host apps from Cowork, Code, and Copilot Studio, and Microsoft says it is opening that runtime to third-party and pro-code builders. If that holds, the runtime becomes as strategic as the chat UI - maybe more so.

Autopilot: The Agent That Does Not Wait for a Prompt

Autopilot is the piece generating the most "wait, what" energy, and for good reason. Previously known as Scout, it is positioned as a persistent, proactive, personal agent that keeps working when you are not.

You give it a name, a role, and a goal. It watches channels, follows up on threads, handles recurring work, and can pick a project back up days later without waiting for you to re-prompt it. That is a different mental model from chat. Chat is pull. Autopilot is push-plus-memory.

Architecturally, Microsoft describes Autopilot as cloud-hosted with its own identity, memory, computer, and workspace, built on Microsoft IQ. It shows up in Teams, Outlook, chats, channels, and documents. You @mention it like a colleague. Permissions, audit trails, and governance are part of the enterprise packaging - which is non-negotiable if anyone is going to let an agent schedule supplier meetings on their behalf.

The supplier review example is a strong stress test for the idea. Autopilot can run a full process: schedule, prep, meetings, follow-ups, stakeholder outreach. That is not a single prompt. It is a campaign of small actions stitched across days. If it works cleanly, it eats a whole class of project-manager glue work. If it is chatty or wrong often, it becomes another notification firehose. The product lives or dies on that judgment call.

Outside coverage has compared Autopilot’s lineage to OpenClaw, an open-source autonomous agent approach, noting the cloud-hosted enterprise version versus local setups, plus stronger guardrails. Demo narratives in that coverage have included retail inventory and overdue-order style workflows. Treat those as reported claims and demos, not as a promise that every tenant will spin up a fleet of Autopilots overnight. Still, the possibility of many Autopilots in one tenant - each with different roles - is exactly why identity and audit matter.

That multi-agent angle is easy to shrug at until you picture a procurement Autopilot, a customer-success Autopilot, and a finance-close Autopilot all living in the same tenant. They are not three chat sessions. They are three named workers with different goals, overlapping calendars, and shared channels. Without clear permissions and audit, that turns into disorder theater. With them, it starts to look like staffing - just with cloud-hosted memory and a computer that does not need PTO.

Straight take: this is the clearest major-platform ship of "agents as digital teammates with corporate identity" we have seen. High interest around Autopilot makes sense. Persistent agents force hard questions about ownership, liability, and cost that a polite chat pane never did.

Home vs Code vs Autopilot at a Glance

If your brain is already sorting these into buckets, here is a clean comparison of the three surfaces as Microsoft describes them:

Another way to say it: Home is the shell, Code is the workshop, Autopilot is the teammate who does not need you in the room. Chat and Office Copilot remain the always-on convenience layer on USL with Auto model routing. The heavier agentic moves - Cowork, Code, Autopilot - sit on UBB, which is where FinOps and Agent 365 controls start mattering.

Billing Split: USL Comfort vs UBB Agents

Microsoft is drawing a bright line between everyday assistance and agentic work.

User subscription license (USL) covers the conversational and Office Copilot experience most people already expect, with Auto model routing deciding which model handles a turn. That is the predictable per-seat world finance teams understand.

Usage-based billing (UBB) covers the agentic pieces: Cowork, Code, Autopilot, and frontier model paths such as Astra and Fable when those are in play. You pay for what the agents do, not only for seats that exist.

That split is smart product design and a little dangerous if left unmanaged. Seat licenses encourage broad enablement. Usage billing encourages experimentation - and sometimes surprise invoices. The same announcement package nods at FinOps for AI and Agent 365 cost controls: spending policies, credit usage visibility, and Cowork outcome insights. Brief, but important. If Autopilot can run a supplier process for days, someone needs a dial on how hard it is allowed to work.

For IT and finance partners reading this: plan for two mental models in one tenant. USL is the floor. UBB is the throttle for digital teammates. Governance without cost visibility is half a plan.

Microsoft IQ, Grounding, and the Quiet Platform Layer

A short stop on the plumbing, because Autopilot and Code are only as good as what they can see safely.

Microsoft IQ is the grounding layer called out across these surfaces. Fabric IQ and Dynamics grounding show up in the broader platform story, along with a plugin registry that keeps systems in sync. Put simply: agents and Code apps are supposed to reason over company data with permissions intact, not scrape whatever they can find in a chat dump.

That matters for Autopilot’s "own identity" claim. An agent with a corporate identity is useless - or dangerous - without the same access controls a human hire would get. Managed Runtime, IQ grounding, and Agent 365-style cost and policy controls are the enterprise sandwich around the shiny demos.

You do not need to memorize every IQ brand name to get the point. The OS-for-work pitch only works if data, code, and agents share one permission story.

Rollout Reality Check

Availability is staged, which is the adult way to ship something this big.

• Home and Code are rolling out in the Frontier program soon
• Autopilot is expanding into private preview soon
• Managed Runtime is already in preview and shared across Cowork, Code, and Copilot Studio
• Broader Code access comes after Frontier, with Premium and Pro preview later

Frontier program access is Microsoft’s usual early lane for customers who live on the bleeding edge and give feedback before the wider wave. Private preview for Autopilot suggests extra caution - appropriate when an agent can @mention stakeholders and schedule on your behalf.

If you are waiting for "everyone gets everything on Tuesday," adjust expectations. The interesting question is not the calendar. It is whether your tenant is ready for agent identity, UBB policies, and a Home surface that becomes the daily launchpad.

What Is Coming Next on the Horizon

Two lighter roadmap notes are worth a glance without turning this into a rumor board.

First, an upcoming Today command center is meant to pull the day into one agent-aware view - less hunting across apps for what needs attention. Second, @Copilot in Teams with shared context points at agents that understand the room, not just the last message you typed in a private pane.

Those are supporting characters next to Home, Code, and Autopilot. Still, they reinforce the same thesis: Copilot wants to be ambient infrastructure for work, not a tab you remember when you are stuck.

Who Should Care First

Not every role needs all three surfaces on day one. A practical cut:

• Knowledge workers and managers - Home’s Chat/Cowork split and Office-in-Copilot will feel most immediate
• Ops, finance, and program folks - Code for trackers and dashboards; Autopilot for recurring follow-up heavy processes
• Developers - GitHub Copilot plus Managed Runtime connectivity; less "replace me," more "ship internal tools faster"
• IT, security, and FinOps - identity, audit, UBB policies, Agent 365 controls; this is where the OS metaphor becomes a governance project

If you only pilot one thing, Autopilot is the cultural change. Code is the leverage change. Home is the habit change. Pick based on whether your bottleneck is follow-through, tooling, or fragmented starting points.

Closing Snapshot

Microsoft rebuilt Copilot around Home, Code, and Autopilot and is openly selling the result as an OS for work. Home merges Chat and Cowork and brings real Word, Excel, and PowerPoint into the Copilot app with live sync. Code turns natural-language descriptions into tenant-hosted apps on Managed Runtime, sharing DNA with GitHub Copilot. Autopilot - the former Scout - is a persistent personal agent with identity, memory, and a workspace that keeps going after you log off.

Everyday Chat and Office Copilot stay on USL. The agentic trio leans on UBB, with FinOps and Agent 365 controls as the cost safety net. Frontier and private preview waves are how this lands before broader seats.

The thesis is simple: chat was the demo era; digital teammates with corporate identity are the platform era. Whether Autopilot becomes a trusted colleague or a clever notification machine will decide if the OS framing sticks. Home has to become the habit. Code has to become safer than a rogue spreadsheet. Autopilot has to earn trust one follow-up at a time.

For now, the product shape is the clearest major-platform bet on agents that do not wait for your next prompt - and that fact by itself is worth watching closely.

Practical example: Product ops release readiness with Home, Code, and Autopilot

Scenario

Priya is a product operations lead at a mid-size UK B2B SaaS company. Every Thursday she owns release readiness: open support themes from the week, known bugs still parked in Azure DevOps, a short status note for engineering and customer success, and a tracker so nobody is hunting across Teams threads at 18:00.

Today her bottleneck is not writing the note. It is the glue work that stretches into the evening - chasing owners for stale items, refreshing the tracker, and making sure nothing customer-facing goes out without a human pass. She already lives in Microsoft 365. The rebuilt Copilot surfaces map cleanly onto that week: Home as the starting hub, Code for a bounded internal tracker, and Autopilot for overnight chase work that still stops short of shipping.

She treats Autopilot as a named digital teammate with a narrow goal, not as an unattended release manager. Anything that reaches customers, partners, or public channels waits for her review in the morning.

What the assistant needs

• Access, under existing tenant permissions, to the release Teams channel, the shared Word brief, the Excel incident sheet, and the Azure DevOps board Priya already uses
• A clear Autopilot identity: name, role (Release Ops Chase), and a goal limited to draft follow-ups and tracker updates - not customer email, not production changes
• A Code-built, tenant-hosted release readiness tracker (if Code / Managed Runtime is available in the tenant) with columns for owner, age, severity, blocker status, and “ready for human review”
• UBB / Agent 365 spending limits so overnight Autopilot work cannot run unbounded
• A hard rule: no external send, no @mention of customers, and no “done” mark on customer-facing copy until Priya approves

Example instruction

In Copilot Home, Priya starts in Chat to orient, then hands the multi-step job to Cowork with a brief like this:

“Build Thursday release readiness for Acme SaaS UK, sprint 38. Pull open P1/P2 themes from the Support channel and the shared Excel incident sheet for the last seven days. Draft a Word status note for engineering and CS with: top themes, known open bugs from Azure DevOps tagged release-38, owners, and blockers. Do not send anything. Leave the Word file in the Release Ops folder and @mention me when the draft is ready for review.”

For the Code slice, still from Home if routing is available, or directly in Code:

“Create a sandboxed release readiness tracker app for sprint 38. Fields: item, source (Support / ADO / Excel), owner, age in days, severity, blocker yes/no, last chase, status (open / waiting on owner / ready for human review). Sync from the Excel sheet and the ADO query I paste below. Host it on Managed Runtime under IT governance. No external connectors.”

For Autopilot, once the draft pack exists:

“You are ‘Release Ops Chase’. Role: overnight follow-up agent for sprint 38 readiness. Goal: between 18:00 and 08:00 UK time, watch the Release Ops channel and the tracker. For each item older than two working days with no owner reply, draft a short Teams nudge to the named owner with the item link and ask for a one-line status. Post drafts only in the private Release Ops draft thread - never in customer channels. Update the tracker’s ‘last chase’ field. Stop if you hit the spend cap or if more than ten nudges are queued. At 08:00, leave me a morning digest of what you drafted and what still needs a human decision. Do not mark any customer-facing communication as sent.”

How to test it

1. Run Home to Cowork once on a past Thursday pack (or a redacted sample) and check that the Word draft cites the right sources without inventing ticket IDs.
2. Stand up the Code tracker on a copy of the Excel / ADO inputs; confirm sandboxed hosting and that only Priya’s group can open it.
3. Give Autopilot a closed overnight window on non-production channels with a tiny spend cap. Verify every nudge lands in the draft thread only, with an audit trail.
4. Morning review gate: Priya opens Home, reads the digest, edits the Word note, and only then posts the approved status to the wider release channel.
5. Failure drill: revoke Autopilot’s right to post outside the draft thread and confirm it cannot escalate to customer-facing surfaces.

Result

No measured bake-off figures are claimed here - treat the following as an illustrative result with explicit assumptions, or use the measurement plan below on a real pilot.

Illustrative result (assumptions stated): Assume one Thursday cycle, ~25 open readiness items, Priya previously spending about 90 minutes on chase-and-compile after 17:00, and Autopilot allowed only draft nudges plus tracker field updates. If Home/Cowork produces a usable first draft of the status note in one pass, Code replaces the ad-hoc spreadsheet with a shared tracker, and Autopilot queues owner nudges overnight for human send/edit in the morning, a realistic target is cutting Priya’s same-evening glue work to roughly a 20-30 minute morning review - provided review time is counted and nothing customer-facing auto-sends. That is an example estimate, not a measured outcome from this article’s product claims.

Measurement plan (prefer this in a live tenant):

• Baseline: time Priya’s Thursday compile + chase for two releases (include review); count missed owner replies by Friday noon; count tracker version conflicts.
• Pilot sample: four consecutive release Thursdays with Home + Code + scoped Autopilot.
• Metrics: minutes to approved status note (including human edit); % of Autopilot drafts accepted without rewrite; count of draft-thread-only posts vs any accidental wider posts (target: zero); UBB credits spent per overnight run vs cap.
• Quality bar: “correct” means every cited ticket/theme exists in source systems, owners match ADO/Excel, and no customer-facing send occurred without Priya’s approval.
• Ship rule: widen Autopilot permissions only after four cycles with zero policy breaches and an accepted-draft rate you are willing to defend to security.

What can go wrong

• Autopilot becomes a notification firehose - too many nudges, wrong owners, or posts outside the draft thread if permissions are loose.
• Code tracker drifts from Excel/ADO if grounding/plugins are incomplete; people trust a stale “ready” flag.
• Cowork drafts sound confident but invent severity or ticket IDs when source access is partial - review has to catch that before the status note ships.
• UBB spend climbs if Autopilot retries noisy channels without a hard cap.
• Teams treat Autopilot like full unattended autonomy; something customer-facing goes out without the morning gate.

Practical takeaway

Use Home as the habit (brief, draft, review), Code for one bounded internal tool under Managed Runtime, and Autopilot for overnight continuation with a named role, a spend dial, and auditable draft-only outputs. Scope the Autopilot job tightly, require human review before anything customer-facing ships, and measure accepted drafts and policy breaches - not gut feel. That is how Copilot-as-work-OS stays workable without turning into an unsupervised release bot.

FAQ

What does Microsoft mean by calling Copilot an OS for work?

Satya Nadella framed the rebuild as Copilot becoming a new OS for work: a shell that hosts apps, manages identity, routes work, and keeps state across sessions - not just a sidebar chat. Jared Spataro’s official Microsoft post describes three surfaces, one agent platform, and digital teammates inside Microsoft 365 with identity, memory, and governance. The rebuilt Copilot app centers on Home, Code, and Autopilot. None of that replaces Excel or Teams; it wraps them so people open Copilot first, then trail into documents, channels, and custom apps.

What are Copilot Home, Code, and Autopilot?

Home is the front door that merges Chat and Cowork so you can review activity, get suggestions, chat instantly, or hand off multi-step projects. Code lets people describe an app, tracker, dashboard, or workflow in everyday language and get a tenant-hosted tool back. Autopilot - previously Scout - is the persistent personal agent that keeps working when you are offline, asleep, or in another meeting. Together they are Microsoft’s bet that agents need a first-class work shell, not a floating bubble.

How does Copilot Home Chat differ from Cowork?

Chat is the instant conversational mode for rewrites, quick summaries, and tone checks. Cowork is the delegation lane for end-to-end complex work - an RFP package, launch kit, leadership briefing, or financial close bundle - where you assign an outcome instead of babysitting every paragraph. Coming next, you can state what you need and Copilot routes you to Chat, Cowork, or Code. That routing layer is the quiet detail that makes the OS metaphor less airy.

Can I edit real Word, Excel, and PowerPoint files inside Copilot?

Microsoft is putting full Word, Excel, and PowerPoint inside the Copilot app - real editable Office files that stay in sync with the Office apps teammates already use, including live team sync and @mention edits. PowerPoint gets on-brand templates; Excel offers change explanations and chart recommendations. Skills bring specialized expertise into the flow, such as financial work in Excel or legal drafting support in Word, rather than one generic model pretending to be every department.

What is Copilot Code and the Managed Runtime?

Code turns natural-language descriptions into sandboxed, tenant-hosted solutions - desktop widgets, interactive dashboards, and cloud-hosted internal apps - using technology lineage shared with GitHub Copilot. Microsoft Copilot Managed Runtime hosts the code safely inside Microsoft 365 under IT governance, with grounding through Microsoft IQ and plugins that keep data in sync. Code moves through the Frontier program first, then broader access, with preview for Microsoft 365 Premium and Pro later; Managed Runtime is already in preview.

How does Microsoft Copilot Autopilot keep working after you log off?

Autopilot is a persistent, proactive personal agent: you give it a name, a role, and a goal, and it watches channels, follows up on threads, handles recurring work, and can resume a project days later without a fresh prompt. Microsoft describes it as cloud-hosted with its own identity, memory, computer, and workspace on Microsoft IQ. It shows up in Teams, Outlook, chats, channels, and documents, and you @mention it like a colleague. Permissions, audit trails, and governance are part of the enterprise packaging.

How is Autopilot billed compared with everyday Copilot Chat?

Everyday Chat and Office Copilot stay on user subscription licensing (USL). The agentic trio - Home’s Cowork-style work, Code, and Autopilot - leans on usage-based billing (UBB), with FinOps and Agent 365 controls as the cost safety net. That split matters for planning: chat seats and agentic credit burn are not the same budget line. Set spend caps and review Agent 365 controls before letting overnight Autopilot work run unbounded in a tenant.

Who should pilot Home, Code, or Autopilot first?

Knowledge workers and managers will feel Home’s Chat/Cowork split and Office-in-Copilot first. Ops, finance, and program folks get leverage from Code trackers and Autopilot for follow-up-heavy processes. Developers keep GitHub Copilot and gain Managed Runtime connectivity for shipping internal tools faster. IT, security, and FinOps own identity, audit, UBB policies, and Agent 365 controls. If you only pilot one thing: Autopilot is the cultural change, Code the leverage change, Home the habit change.

How should teams scope Autopilot safely in a real tenant?

Give Autopilot a named role and a narrow goal - draft follow-ups and tracker updates, not customer email or production changes. Prefer draft-only posts in a private thread, hard spend caps, and a morning human review before anything customer-facing ships. Keep permissions, audit trails, and Agent 365 controls in place; widen access only after clean cycles with zero policy breaches. Outside coverage has compared Autopilot’s lineage to OpenClaw-style autonomous agents - treat demos as reported claims, not a promise every tenant will spin up a fleet overnight.

Is Copilot Code meant to replace professional developers?

No. The framing is complementary: citizen builders use Code for operational tools, while developers keep deeper GitHub Copilot workflows and gain hooks into the same agent fabric. Solutions stay sandboxed and tenant-hosted so IT has a place to stand instead of another spreadsheet glued to email. That only works if the sandbox is real and plugins stay trustworthy. Code plus Managed Runtime is Microsoft’s answer to shadow IT pressure, not a claim that pros are obsolete.