Direct answer: Microsoft has redesigned its work-focused Copilot around three new capabilities: Home combines Chat, Cowork and live Office editing; Code builds small apps and workflows from natural-language instructions; and Autopilot is a persistent cloud agent that can continue delegated work without waiting for another prompt. Home and Code are beginning through Microsoft’s Frontier program, while Autopilot is expanding in private preview—so most users should treat this as a staged rollout, not an instant general release.[1]
Do this first: Check your tenant’s Frontier eligibility, choose one low-risk workflow, assign an owner, review data access and set a small usage budget. Do not give an early Autopilot broad permissions or let a generated app write to production systems until it passes a controlled pilot.
New Microsoft Copilot availability at a glance
| Capability | What it does | Availability announced September 25, 2026 | Best first test |
|---|---|---|---|
| Home | Unifies Chat and Cowork; creates or edits real Word, Excel and PowerPoint files | Starts rolling out through Frontier in the coming weeks | Turn an approved brief into a shared document or deck |
| Code | Builds trackers, dashboards, automations, widgets and internal apps from a description | Frontier rollout at the end of September, followed by broader availability; Microsoft 365 Premium and Pro preview later in 2026 | A read-only project-status dashboard |
| Autopilot | Persistent agent with its own identity, memory, computer and workspace | Private preview expands at the end of September | Monitor one channel and prepare a review-only follow-up list |
| Copilot Managed Runtime | Microsoft-hosted environment for governed internal apps | Public preview | Deploy a non-sensitive internal utility after local and preview testing |
Microsoft says routine Chat and Office work remains tied to user subscription licensing, while long-running Cowork, Code and Autopilot work uses usage-based billing. The launch post does not provide a simple flat price for these three new capabilities.[1]
What changed in the new Copilot?
Home: Chat, delegated work and Office files in one place
Home is the new starting screen. Chat handles quick questions and drafts, while Cowork is intended for work delegated end to end, such as a customer briefing or launch kit. Office in Copilot can create or update editable Word documents, Excel workbooks and PowerPoint presentations while collaborators work on the same files.[1]
The practical change is that Copilot is moving beyond returning text in a chat window. A useful pilot should therefore measure the quality of the resulting file—not merely whether the answer sounds convincing.
Code: natural-language app building
Code lets a user describe an app, tracker, dashboard, workflow or automation. Microsoft says it uses underlying technology from GitHub Copilot, runs in a sandbox and can host apps inside the organization’s tenant through Copilot Managed Runtime.[1]
Code is not a reason to skip software review. Generated internal tools can still expose the wrong data, apply faulty business logic or trigger unintended actions. Treat each output as software: establish an owner, test permissions, validate calculations, review connectors and maintain a rollback path.
Autopilot: a persistent cloud agent
Autopilot—previously called Scout—is designed to keep working after the user leaves. Microsoft describes it as having its own identity, memory, computer and workspace within the tenant. It can watch channels, follow up on threads, run recurring tasks and resume a project later.[1]
That persistence is also the main risk. A normal chat mistake ends with the response; a persistent agent can repeat a bad action. Start with observation and drafting, require approval before external communication or record changes, and define an immediate way to pause the agent.
Important: Copilot Autopilot is not Windows Autopilot. Windows Autopilot provisions and configures devices; the newly announced Copilot Autopilot is a persistent workplace AI agent.
How to check access
1. Check the Frontier program
Microsoft says the new Copilot rollout begins through its Frontier program. Availability can vary by tenant, license, region and preview enrollment. If the new Home or Code interface is absent, that does not prove a setup failure; the rollout may not have reached the tenant yet.[1]
Ask the Microsoft 365 administrator to record:
- the tenant and region being tested;
- the assigned Copilot license;
- Frontier enrollment status;
- whether preview features are allowed;
- approved connectors and blocked data sources;
- the pilot users and security groups;
- the spending policy and review date.
2. Separate what is available now from what is preview-only
Use the announcement as a timing guide, not a promise that every feature is visible today. Home and Code have a staged Frontier rollout, Autopilot remains a private preview, and Copilot Managed Runtime is public preview.[1][2]
Avoid publishing internal instructions that say “click this button” until the button is visible in your tenant. Preview interfaces and names can change.
3. Confirm billing controls before agentic use
Microsoft separates everyday subscription usage from usage-based agentic work. The launch places Cowork, Code, Autopilot and advanced long-running tasks under usage-based billing, with cost-management controls intended for admins and end users.[1]
Before enabling a pilot:
- set a maximum test budget;
- restrict who can request or consume credits;
- choose the approved model families;
- review usage at least weekly;
- define what outcome justifies continued spend.
Do not estimate production cost from a single short demo. Measure several realistic tasks, including failed attempts and revisions.
Safe pilot plan for Home, Code and Autopilot
Phase 1: test Home with a known document
Choose a non-confidential, approved brief and ask Home to create a Word document or presentation. Compare the output with the source line by line.
Check:
- facts, names, dates and totals;
- whether citations or source references survive into the file;
- formatting and brand-template fidelity;
- edit history and collaborator access;
- whether Copilot changed content that was meant to remain fixed.
A successful demo is not “Copilot made a deck.” It is “the team reviewed the deck, found no unsupported claims, and saved measurable editing time.”
Phase 2: build a read-only app with Code
A first Code project should be useful but reversible. Good options include:
- a project-status dashboard;
- a searchable policy index;
- a campaign checklist;
- a meeting-action tracker;
- an inventory viewer with no update permission.
Copy and adapt this build brief:
Build an internal project-status dashboard.
Users:
- Members of [SECURITY GROUP] only.
Data:
- Read from [APPROVED SOURCE].
- Do not write, delete or modify records.
- Display “No data retrieved” when a query returns nothing.
Required views:
- Projects by owner and status.
- Overdue items.
- Items with no assigned owner.
- Last successful data refresh.
Safety:
- Do not expose hidden fields or personal data.
- Log access and failed connector calls.
- Require a human review before sharing beyond the pilot group.
- Provide a clear error state instead of inventing values.
Test it with invented or sanitized records before connecting live business data.
Phase 3: give Autopilot an observation-only role
A cautious first Autopilot should monitor one low-risk location and prepare drafts for review. For example:
Name: Project Follow-up Assistant
Role: Review the [PROJECT] Teams channel and prepare a daily follow-up list.
Goal: Identify explicit commitments, owners and due dates.
Boundaries:
- Do not send messages, emails or meeting invitations.
- Do not edit files, tasks or records.
- Do not infer an owner or due date when none was stated.
- Label uncertain items “Needs human review.”
- Include a link to the original message for every item.
- Stop and alert the owner if access or source retrieval fails.
Review false positives, missed commitments and permission behavior for at least a full work cycle before adding any write capability.
Copilot Managed Runtime: what IT needs to know
Copilot Managed Runtime is the hosting layer behind apps made through Cowork, Code and Copilot Studio, and it is also open to professional developers. Microsoft says apps run in a Microsoft-hosted environment, use Entra authentication, inherit tenant policies and appear in the Microsoft 365 admin center for monitoring and management.[2][3]
Microsoft’s documentation describes three creation paths:
- business users describe an app in Cowork;
- makers build through Copilot Studio;
- developers use the Managed Runtime SDK and
mscommand-line interface.[3]
All three produce apps governed through the same runtime, but that does not remove the organization’s responsibility to review who can build, which connectors are approved, who can share apps and what data each app can access.
Admin readiness checklist
- [ ] Create a dedicated pilot security group.
- [ ] Review allowed connectors and sharing rules.
- [ ] Confirm Conditional Access and data-loss-prevention policies.
- [ ] Assign an owner and backup owner to every app and agent.
- [ ] Record the data classification for each source.
- [ ] Block production write access during the first pilot.
- [ ] Test revocation: remove a user and confirm access disappears.
- [ ] Test pause, rollback and incident-response procedures.
- [ ] Monitor health, usage and spend in the admin center.
- [ ] Set a retirement date for abandoned experiments.
Developer quickstart for Copilot Managed Runtime
Microsoft’s preview quickstart uses Node.js, Git and the @microsoft/managed-apps-cli package. The flow signs in with Microsoft Entra, scaffolds an app, runs it locally, pushes a commit to preview and then explicitly deploys a successful build.[4]
Install and authenticate:
npm install -g @microsoft/managed-apps-cli
ms --version
ms auth login
Create a starter app:
ms app create hello-world --display-name "Hello World"
cd hello-world
npm install
ms app dev
Use the local play URL for development. Commit and push only after the app behaves correctly, then open the hosted preview and validate the exact build before running the deployment command. Microsoft’s documented process keeps preview and live deployment as separate steps.[4]
Before deploying a real app, add automated tests for business rules and manually verify authentication, authorization, connector failures and empty results. Do not paste tenant IDs, tokens or production credentials into a prompt or source file.
Permission ladder for persistent agents
Use a staged permission ladder rather than enabling everything at once:
| Stage | Allowed | Not allowed |
|---|---|---|
| 1. Observe | Read one approved source and produce a private summary | Messages, edits, external tools |
| 2. Draft | Prepare messages, tasks or documents for human review | Sending or publishing |
| 3. Confirmed action | Execute a narrow action after explicit approval | Recurring autonomous writes |
| 4. Bounded automation | Run a tested recurring task with limits and logs | New tools, scopes or recipients without review |
Return to a lower stage after a permission change, model change, connector change or serious failure.
What to measure during the pilot
Track outcomes rather than impressive demos:
- completion rate without human rescue;
- factual or calculation errors;
- unauthorized or unnecessary data access;
- incorrect actions prevented by approval gates;
- human review time per output;
- cost per accepted result;
- rollback and pause time;
- user-reported confusion about whether an action was performed.
Keep a failure log. A task that is fast but frequently needs correction may cost more than the manual workflow it replaces.
FAQ
Is Microsoft Copilot Autopilot available to everyone?
No. Microsoft said Autopilot would expand in private preview at the end of September 2026. Home and Code are starting through the Frontier program, with broader Code availability planned later.[1]
Is Copilot Autopilot the same as Windows Autopilot?
No. Copilot Autopilot is a persistent AI agent for workplace tasks. Windows Autopilot is Microsoft’s device provisioning and deployment service.
Can Code build an app from a prompt?
Microsoft says Code can create apps, trackers, dashboards, automations and workflows from natural-language descriptions. It runs in a sandbox and can use Copilot Managed Runtime for governed hosting inside the organization’s Microsoft 365 environment.[1][2]
Is Copilot Managed Runtime generally available?
No. Microsoft introduced it as a public preview, and its Learn documentation labels the feature prerelease and subject to change.[2][3]
Does a generated app automatically meet every compliance requirement?
No. The runtime inherits Microsoft 365 identity and governance controls, but administrators still need to configure policies, approve data connections, control sharing and review each app’s business logic and permissions.[2][3]
How should a company test Autopilot safely?
Start with one observation-only task, one approved source and one owner. Require human review, prohibit external messages and record every source, output and error. Add permissions only after repeatable testing.
How is the new agentic work billed?
Microsoft says everyday Copilot work uses a user subscription license, while Cowork, Code, Autopilot and frontier-model work use usage-based billing. The launch announcement does not list a single flat rate for the new capabilities.[1]
Last checked: September 26, 2026.