Microsoft is rolling out Copilot Autopilot in private preview, turning its earlier Scout project into a persistent enterprise agent inside the new Copilot experience.

The launch is part of a broader Copilot reset. Microsoft introduced three new Copilot capabilities on September 25: Home, Code, and Autopilot. Home is meant to be the starting point for chat, delegated work, and Office files. Code lets workers build apps, dashboards, automations, and internal tools from natural language. Autopilot is the long-running agent layer.

Microsoft says Home and Code will start rolling out through its Frontier program in the coming weeks, while Autopilot is expanding to private preview at the end of September.

The OpenClaw angle is what makes this more than another Copilot feature announcement. OpenClaw says Autopilot's foundation is OpenClaw, and Omar Shahine, who leads the Microsoft team building the product, said Microsoft is building Autopilot on OpenClaw while working with Peter Steinberger and the OpenClaw Foundation to make it an enterprise-grade runtime.

That gives OpenClaw one of its clearest enterprise endorsements yet. A project that first became known as a self-hosted personal agent framework is now sitting underneath a Microsoft 365 agent product aimed at companies, IT admins, and governed workplace automation.

What Autopilot does

Autopilot is Microsoft's name for a persistent agent that can keep working after the initial prompt.

Microsoft describes the product as a digital teammate. A user can give it a name, role, and goal, then ask it to monitor channels, follow up on threads, run recurring work, or resume a project days later. In Microsoft's supplier-review example, Autopilot can build the schedule and workback plan, prepare meetings, chase stakeholders for updates, and handle follow-up.

The important shift is from request-response chat to delegated work. Copilot Chat answers or drafts. Cowork takes on a specific work package. Autopilot is meant to stay attached to an objective over time.

Microsoft says Autopilot is cloud-hosted, so it can continue operating when the user is away. It lives inside the customer's tenant with its own identity, memory, computer, and workspace. It is grounded in Microsoft IQ, the company's enterprise intelligence layer for connecting Microsoft 365, business data, workflows, documents, meetings, chats, and permissions.

That architecture matters because the product is not being pitched as a consumer companion. It is designed to show up in Teams, Outlook, chats, channels, and documents, where people can mention it like a colleague while IT still gets permissions, audit, and governance controls.

From Scout to Autopilot

Autopilot was previously called Scout.

Microsoft introduced Scout at Build 2026 as an always-on agent for Microsoft 365. Early reporting described it as an OpenClaw-based assistant that could operate across desktop and browser workflows, connect to inboxes and calendars, and build persistent skills around the way a person works.

That Scout announcement positioned the product as the first of a broader class Microsoft called Autopilots: agents with their own identity that can act continuously on a user's behalf rather than waiting for every step to be prompted.

The September Copilot announcement makes that naming official. Scout is now Autopilot, and it is being moved into the main Copilot story rather than sitting as a separate Build-era experiment.

There is also a deployment change. InfoQ reported in June that the earlier Frontier version ran as an OpenClaw-like desktop app connected to Graph and Work IQ, while Microsoft Scout in private preview was moving toward a cloud-based Autopilot agent. Microsoft's new post now emphasizes cloud hosting, tenant identity, memory, computer, and workspace.

Why OpenClaw matters here

OpenClaw is relevant because Autopilot needs more than model quality. It needs an agent runtime: channels, memory, tool access, approvals, scheduling, routing, command execution, browser automation, and recovery from long-running work.

Those are exactly the surfaces that make agent products useful and risky at the same time.

OpenClaw's post highlights several areas where Microsoft contributors have been working upstream:

  • policy conformance checks for agent configuration
  • message-routing checks to verify conversations reach the intended agent
  • native Windows support through the OpenClaw companion
  • sandbox and execution-container integration for Windows environments
  • reliability fixes for queues, restarts, completion streams, and database recovery
  • safer approval prompts, secret redaction, and message handling

The most important point is not that every upstream contribution maps directly to an Autopilot feature. OpenClaw is careful about that. The public record shows something broader: Microsoft engineers are contributing to the runtime layer that both Autopilot and ordinary OpenClaw users can benefit from.

That makes the relationship strategically interesting. Microsoft gets a faster path to a persistent agent runtime. OpenClaw gets enterprise hardening work, Windows support, policy tooling, and reliability improvements from engineers building against real Microsoft 365 workflows.

The governance problem

Autopilot's promise is also its risk.

An agent that can watch channels, follow up with colleagues, work across documents, and continue while the user sleeps is far more useful than a chatbot. It also needs clearer boundaries than a chatbot.

Microsoft is leaning heavily on enterprise controls to answer that concern. Autopilot has its own identity rather than borrowing all of a user's authority invisibly. Microsoft says it runs with permissions, audit, and governance behind it. The broader Copilot platform also includes spending controls, model-family policies, plugin approval, Agent 365 cost management, and administrative oversight.

The Windows side of the story matters too. In June, Microsoft described Microsoft Execution Containers as a policy-driven execution layer for agents on Windows and WSL. The company said OpenClaw can run its node and gateway securely on Windows using MXC, and framed containment as a way to keep dynamic agent behavior from turning into uncontrolled system risk.

That is the right category of problem. Long-running agents need infrastructure boundaries, not just prompt instructions. They need scoped identity, approval flows, audit trails, sandboxing, plugin governance, and a way for administrators to ask, "What can this agent do right now?"

Why it matters

Microsoft is trying to make Copilot less like a chat window and more like an operating layer for work.

Home organizes the work context. Code turns natural-language requests into small internal software. Autopilot keeps delegated work moving across time. Together, they point to a version of Microsoft 365 where the main unit is no longer just a document, spreadsheet, slide deck, or chat thread. It is an agent-backed workflow.

For OpenClaw, the story is a credibility jump. OpenClaw is no longer just the open-source agent framework that power users run locally. It is now part of Microsoft's enterprise agent roadmap, with upstream contributions flowing back into the project.

For buyers, the question is whether the private preview can turn that architecture into dependable work. Autopilot will have to prove that it can stay useful without becoming noisy, act proactively without overstepping, and integrate deeply enough with Microsoft 365 to justify usage-based billing for long-running agentic work.

Our take

This is one of the clearest signs yet that the agent market is moving from demos to runtimes.

The model is not the full product. The product is the loop around the model: identity, memory, permissions, tools, channels, scheduling, approvals, recovery, and observability. Microsoft's Autopilot announcement makes that visible because it is explicitly about a cloud-hosted agent with a tenant identity, its own workspace, and enough persistence to keep work moving without constant prompting.

OpenClaw is the important part of the stack because it already lives in that messy runtime layer. Microsoft building on it, contributing back to it, and wrapping it in enterprise governance is a strong signal that open agent infrastructure is becoming part of mainstream workplace software.

The caveat is obvious: private preview is not proof of production reliability. But the direction is clear. Microsoft is not just adding more Copilot buttons. It is trying to make Copilot a place where work can be delegated to persistent agents, and OpenClaw is now part of that bet.