Microsoft's New Copilot Has Three Doors: Home, Code and Autopilot

On September 25, 2026, Microsoft introduced a rebuilt Copilot. This was not a product refresh so much as a repositioning: Copilot becomes an operating layer for work, with Home as the place you orient yourself, Code as the place you turn a sentence into something that runs, and Autopilot as a cloud-hosted teammate that keeps going after you stop watching. Microsoft shipped new FinOps for AI controls alongside it. For engineering leaders, the important parts are not the feature list. They are three questions: who Code turns into a builder, what Managed Runtime lets run inside your tenant, and how usage-based billing lands on the budget sheet.

1. Three doors, one app

The official Microsoft blog frames the rebuild around three capabilities. Home is the new starting point where Chat and Cowork come together, with Office in Copilot bringing the full power of Word, Excel and PowerPoint into the experience. Code lets everyone build their own solutions with the tools to run them safely. Autopilot is a persistent, proactive and personal agent that keeps working even when you are not. Microsoft also signalled a direction that matters for governance: soon you will not choose a mode at all. You state what you need to accomplish, and Copilot routes the work to Chat, Cowork or Code. The auditable object stops being the app a person opened and becomes the routing policy itself.

# The new Copilot is one app fronting three capabilities, and the
# routing decision is being taken away from the user.

COPILOT_SURFACES = {
    "home":      {"chat", "cowork", "office_in_copilot"},
    "code":      {"widgets", "dashboards", "internal_apps"},
    "autopilot": {"name", "role", "goal"},   # persistent, cloud-hosted
}

# Microsoft's stated direction: you state the outcome, Copilot picks
# Chat, Cowork or Code. Which means the thing you must govern is no
# longer the app a person opened. It is the routing policy itself.

Home merges Chat and Cowork into one starting point

2. Code adds a fourth unit of work

Microsoft is explicit about what Code changes. Until now, the unit of knowledge work was the file — the document, the spreadsheet, the deck. Those are not going anywhere, but Code adds a fourth: small, purpose-built solutions anyone can create to get a job done. Describe an app, tracker, dashboard, automation or workflow in natural language and Copilot chooses an approach and builds it, from persistent desktop widgets and interactive dashboards to cloud-hosted internal apps you can share with your team. It runs in a sandboxed environment, can be hosted securely within your tenant, and is powered by the same underlying technology as GitHub Copilot. For IT, the significance is that shadow IT now has a first-party door.

# What Code actually produces, per Microsoft's own description:
# persistent desktop widgets, interactive dashboards, and cloud-hosted
# internal apps you can share with a team. It runs sandboxed and can
# be hosted inside your tenant. Powered by the same underlying
# technology as GitHub Copilot.

CODE_OUTPUT_CLASSES = {
    "widget":    {"runs": "desktop", "shares": "self",  "data_scope": "personal"},
    "dashboard": {"runs": "desktop", "shares": "team",  "data_scope": "workspace"},
    "internal_app": {"runs": "tenant", "shares": "org", "data_scope": "business"},
}

def review_required(artifact):
    """The governance question is scope, not code quality."""
    return artifact["shares"] in {"team", "org"} or artifact["data_scope"] != "personal"

3. Autopilot works while you sleep

Autopilot, previously called Scout, is Microsoft's digital teammate. Give it a name, a role and a goal, and it goes to work: watching channels, following up on threads, running recurring work and picking a project back up days later, without waiting for a prompt. Microsoft's example is a supplier review process where Autopilot builds the schedule and workback plan, then handles prep, meetings and follow-ups on its own, down to reaching out to stakeholders for updates. It is cloud-hosted, so it keeps working while you sleep. That creates an accountability question most orgs have not answered: a long-running agent that initiates contact with people needs a named owner and a reviewable action log.

# Copilot Managed Runtime is hosting infrastructure that lets code run
# safely inside the company's own Microsoft 365 environment: governed
# by IT, shareable by everyone else. It is in preview and also
# accessible inside Code.

RUNTIME_CONTROLS = {
    "hosting":        "your Microsoft 365 tenant",
    "governed_by":    "IT",
    "shared_with":    "teammates",
    "live_data":      True,
    "reached_from":   "anywhere",
    "also_powers":    ["Cowork", "Code", "Copilot Studio apps"],
    "status":         "preview",
}

# Preview means: enumerate what it can reach before you let it reach it.

Code hands non-developers a fourth unit of work

4. Managed Runtime keeps the keys with IT

Copilot Managed Runtime is the infrastructure that makes the rest defensible. Microsoft describes it as hosting infrastructure that lets code run safely right inside your company's Microsoft 365 environment: governed by IT but easy for everyone else, so you can share an app with teammates, connect it to live data and reach it from anywhere. The same foundation enables apps built in Cowork, Code and Copilot Studio, and Microsoft is opening it to third-party and pro-code developers. It is in preview and also accessible inside Code. In preview, the correct sequence is to enumerate what it can reach before deciding whether it should. Concretely: list the connectors and data sources the runtime can bind to, decide which of them are acceptable for a preview-stage workload, and only then widen the group of people who can publish into it.

# The pricing change is the part that lands in finance. Everyday AI
# stays on a user subscription licence with Auto routing on accuracy,
# speed and cost. Agentic work moves to usage-based billing, which now
# covers Cowork, Code and Autopilot, plus frontier models.

PRICING = {
    "USL": {"covers": ["chat", "office apps", "model selection"], "runtime": "Auto"},
    "UBB": {"covers": ["Cowork", "Code", "Autopilot", "frontier models"]},
}

# FinOps for AI controls Microsoft shipped alongside it:
FIN_OPS = [
    "Agent 365 cost management extended to Code and Copilot Managed Runtime",
    "Microsoft Copilot Studio agents planned for October",
    "spending policies at scale, manageable with API access",
    "user credit requests routed into existing approval workflows",
    "per-group model family allowlists (which also bound what Auto can pick)",
    "end-user view of credit usage, remaining balance and history",
]

5. The pricing change is the real headline

The financial implications may outlast the features. Microsoft split two paths. Everyday AI — quick answers, first drafts, summaries, analysis — stays on a user subscription licence, with a component called Auto at its heart that weighs accuracy, speed and cost on each request to route to the best-suited model. Agentic work moves to usage-based billing, which now covers Cowork, Code and Autopilot plus frontier models such as Astra and Fable. The FinOps for AI controls span Agent 365, Insights and Copilot: extended cost management, spending policies manageable at scale through API, end-user credit requests routed into existing approval workflows, per-group model family allowlists, and a self-service view of credit usage and balances for end users.

# A readiness gate you can run before enabling the Frontier features.
# Nothing here is Microsoft-specific policy -- it is the minimum you
# need so that a sandboxed app builder does not become shadow IT.

CHECKLIST = {
    "identity":   "which groups get Code, and what do their tool scopes say?",
    "data":       "what can the runtime reach: mail, files, Teams, Dataverse?",
    "budget":     "tenant and group budgets set before first credit is spent?",
    "models":     "which model families are visible to which groups?",
    "approval":   "where do end-user credit requests land, and who decides?",
    "lifecycle":  "who reviews and retires apps once their author leaves?",
}

def ready(state):
    return [k for k, v in state.items() if not v] or "ship it"

Usage-based billing makes cost control an admin job

6. Six questions before you switch it on

If these features appear in your tenant tomorrow, do not just enable them. Ask six things in order. Identity: which groups get Code, and what do their tool scopes actually say? Data: what can the runtime reach — mail, files, Teams, business data — and at what scope? Budget: are tenant and group budgets set before the first credit is spent? Models: which model families are visible to which groups, keeping in mind that this also bounds what Auto can pick? Approval: where do end-user credit requests land, and who decides? Lifecycle: when the author of a shared app leaves, who reviews and retires it? When all six have answers, join the Frontier program.