A woman reviews a multi-panel AI assistant dashboard on a large monitor in a modern office.
Microsoft wants AI agents to stop borrowing your credentials. In a Microsoft Foundry blog post published during Ignite week, Technical Program Manager Amanda Foster describes agents that act in Microsoft 365 under their own identity. They can join Teams group chats, answer email, edit Excel workbooks and build PowerPoint decks, even when nobody is signed in. Each one also has a human manager who answers for it.

Microsoft's own documentation calls this kind of agent an autopilot. It isn't brand new: the Microsoft Learn pages behind it were last updated in late August 2026. WindowsForum also reported earlier that Microsoft used similar wording in a June Microsoft Foundry blog post announcing autopilot agents in public preview, it said these agents have user accounts with a productivity license. The new post adds some practical details. It sets out the problem Microsoft says it is solving, names Nous Research's Hermes Agent as an early adopter, and gives figures from Microsoft's internal use. For IT pros, the more useful material is in the documentation: it says who can build these agents, who approves them, what they cost in licences, and where the data ends up.

A woman reviews a multi-panel AI assistant dashboard on a large monitor in a modern office. The problem: agents that borrow your identity​

According to Foster's post, an agent without its own account can only work in Outlook or Teams with your permissions. That's fine for a personal assistant. It fails in two common cases:

  • No user is signed in. An agent started by an event, such as a new bug assignment, has nobody to act for. It either can't take Microsoft 365 actions at all or has to keep someone's credentials to do so.
  • Group chats. In a shared thread, the agent has to pick whose permissions to use. Whoever it picks, actions get attributed to someone who didn't ask for them, and chat members can see content they aren't allowed to access.

Microsoft Learn describes the same limitation: without an agent user account, an agent can perform Microsoft 365 actions, such as sending an email or editing a document, only on behalf of a signed-in user. If you've ever wondered why a shared AI assistant in a group chat feels like a compliance problem waiting to happen, this is the reason.

Section summary: The fix is an identity, not a smarter model. The agent acts as itself, so audit logs show what it did, not what your account supposedly did.

Two identity objects with different jobs​

Every Foundry agent gets a Microsoft Entra agent identity. What makes an autopilot different, per Microsoft's integration documentation, is that an autopilot acts as itself under its own identity rather than on behalf of a user, because it has an Entra agent user account in addition to the agent identity that every Foundry agent has.

The two objects can't stand in for each other:

ObjectWhat it isWhat it's for
Agent identityA service principalHolds the agent ID, sponsor and authentication permissions. For an autopilot, it secures the infrastructure that runs the agent
Agent user accountA user objectDisplay name, manager, UPN, mailbox, calendar, OneDrive, Teams presence and a place in the org chart

In Microsoft's words, for an autopilot, the agent identity serves as its infrastructure identity, while the agent user account represents the autopilot when it performs Microsoft 365 actions.

Microsoft is also careful about what does not make something an autopilot. Autonomy alone doesn't count. Foundry has three agent types:

  • Assistive agents act on behalf of a signed-in user.
  • Background service agents run on their own with app-only permissions. Microsoft says this type acts as itself through app-only permissions, without a signed-in user or agent user account. It can't perform Microsoft 365 actions.
  • Autopilots act as themselves in Microsoft 365, including in group settings.

The reverse also holds. Microsoft Learn says an autopilot doesn't have to be fully autonomous. Your organisation controls when it responds, who it can talk to, what it can access and which actions it can take.

Blueprints: build one, hire many​

You don't build an autopilot directly. You build a blueprint, a template that defines the APIs the agent can call, the MCP tools it can use, and custom code for behaviour such as when it responds. It is deployed as a Foundry hosted agent. Microsoft Learn says an autopilot has a one-to-many shape: one blueprint, and many hired instances, where each instance gets its own agent identity and its own agent user account.

The important design rule is that a blueprint grants capability, never access. Foster's example is a "release captain" agent that knows how to update Azure DevOps work items and write to SharePoint. The manager of each instance decides which project and which site it can reach. Microsoft Learn spells this out: giving an autopilot a SharePoint tool doesn't give it any SharePoint site, and giving it a mailbox doesn't let it send mail.

Microsoft explains why this matters. If you grant one hand-built agent your team's resources, nobody else can reuse it without inheriting that access, so every team builds its own copy. Ten teams later you have ten near-identical agents whose controls slowly diverge. With a blueprint, policy is set once and inherited by every instance. Updating the blueprint updates every instance, and blocking it stops all of them.

The lifecycle documentation also covers the end of an instance's life. When an instance is offboarded, the agent user account is removed, its memberships are revoked, and its access ends immediately.

Section summary: The blueprint is the thing you govern. Each instance is the thing you grant access to. Keep those separate and you avoid a sprawl of near-identical agents.

"Act for you, not as you"​

Foster's main example is "Office of Amanda," an AI chief of staff she says runs in production at Microsoft. It gets access to her calendar and mailbox through ordinary Exchange delegation, the same way a human assistant would. It can be added to security groups and Microsoft 365 groups, assigned access packages and sent shared documents. When it sends email, the message comes from the agent under its own identity, with its own audit trail.

The post is also frank about where agents differ from human employees:

  • An agent has nothing at stake personally, so accountability has to sit with the people around it.
  • It doesn't notice when it has gone past what it knows. It carries on confidently where a person would stop and ask.
  • A thousand employees make a thousand different mistakes that partly cancel out. A thousand copies of one autopilot share the same blind spots and fail together.

That last point explains the fleet-level kill switch. Because every agent is an instance of a blueprint, one action can disable a whole class of agents. It's a useful control. It also means a single bad blueprint update reaches the whole fleet at once, so treat blueprint changes like production code changes.

Where Agent 365 fits​

Microsoft describes Agent 365 as its enterprise control plane for agents. Per the integration documentation, every Foundry agent you publish appears in the Agent 365 registry automatically, giving administrators one inventory of every agent without manual registration. For autopilots, after publishing and administrator approval, the blueprint appears in the Agent 365 registry, and people can hire autopilot instances from it in Microsoft Teams and other Microsoft 365 surfaces.

Two points to note before rollout:

  1. Being in the registry doesn't mean you get activity telemetry. For hosted agents, activity data collection is supported using the Agent 365 SDK and needs explicit configuration plus Entra permissions for the Agent 365 observability service. Microsoft also says no data flows unless the tenant has a qualifying licence and an administrator has accepted the Agent 365 terms.
  2. Data residency changes. Foundry data, models and logs stay in the Azure region of the Foundry resource. Agent 365 inventory, analytics and governance data follow the geography of the Entra tenant. When activity data flows into Agent 365, it moves from the first model to the second. Individual Foundry resources can opt out of Agent 365 data collection.

Reality check: licensing and preview status​

The blog post says the agents need "no new systems or processes to learn." The quickstart documentation tells a fuller story. Requirements include:

  • Tenant enrolment in the Frontier preview program, and acceptance of the Agent 365 terms of service.
  • At least one Microsoft 365 Copilot license or one Microsoft Agent 365 license, including Microsoft E7.
  • An available Agent 365 Frontier licence. Eligible tenants get a 25-seat preview subscription, and each Foundry autopilot instance consumes one license, because each instance creates an agent user account.

If your tenant has no free seats, the build will complete and then fail when someone tries to create an instance. Check your seat count first.

Not every agent needs this. A Dev.to explainer by developer Manoranjan Rajguru argues that if an agent only ever responds to a specific signed-in user's request, an assistive agent with delegated permissions is simpler, cheaper, and needs no Agent 365 licensing. That's a sensible rule of thumb: use an autopilot when the work is shared or event-driven, not by default.

Quickstart: build and hire your first autopilot​

According to the Microsoft Learn quickstart, the process runs as follows.

Tools: Azure CLI, Azure Developer CLI (azd) and a running copy of Docker. Create all resources in a region that supports hosted agents.

Roles:

StepRequired role
Provision infrastructureOwner, or Contributor plus Role Based Access Control Administrator, at resource-group scope
Build the blueprintFoundry User (project scope) plus AcrPush or Container Registry Repository Writer (registry scope)
PublishFoundry User (project scope)
ApproveGlobal Administrator or AI Administrator
Create an instanceMembership in the admin-selected hiring scope

The Foundry roles were recently renamed from their "Azure AI" names, so you may still see the old names in places. You don't need an Entra directory role to create the agent identity blueprint.

Steps:

  1. Clone the C# or Python autopilot sample and open a terminal in its folder.
  2. Sign in with az login --tenant <tenant-id> and azd auth login --tenant-id <tenant-id>, then run azd provision. This one command provisions the Foundry account and project, a model deployment, Azure Container Registry, Application Insights and a Log Analytics workspace. It then builds the container image, creates the hosted agent and publishes the blueprint. Run azd provision --preview first if you want to see what will be created.
  3. Save your deployment values with azd env get-values. You should see the agent name, version and blueprint ID.
  4. Check the publish settings. The publish API (version 2025-11-15-preview) must set publishAsAutopilot: true, publishScope: Tenant and useAgenticUserTemplate: true, and include an agenticUserTemplate object. Use canRespondWithoutMention to control whether the agent replies to every message on its Teams surfaces or only when @mentioned. Don't put secrets in metadata fields, because users can see them.
  5. Admin approval. In the Microsoft 365 admin center, go to Agents > All agents > Requests. Find the autopilot in the Pending activate state and run the wizard: choose the hiring scope (None, All users, or specific users or groups), apply a policy template, grant admin consent, and publish. The registry should then show the autopilot as Available.
  6. Hire an instance. In Teams go to Apps > Agents for your team, or in Copilot go to Agents > Agents for your team. Select Create instance, set the name (up to 32 characters), alias and domain, and confirm who manages it. You become the manager, and the agent should start a Teams chat with you.

Common failures:

  • Provisioning stops partway through: you have Contributor without RBAC Administrator, so the role assignments can't be created.
  • Publishing returns "version already exists": increase the version number and publish again.
  • Create instance is missing: check Frontier enrolment, whether the admin has activated the agent, and whether you're in the hiring scope.
  • Hiring fails with a licensing error: there are no free Frontier seats.
  • The agent doesn't appear in Teams search: instance creation is asynchronous, so wait a few minutes.
  • Running azd down deletes the Azure resources but not the instances people have hired. Retire the blueprint with your admin.

Nous Research and Microsoft's own numbers​

Microsoft names Nous Research's Hermes Agent as an external example. Each Hermes agent gets its own work account with email, cloud storage, a calendar, a chat profile and a manager. The post says Hermes will come in two versions: Hermes Business, a SaaS agent hosted by Nous, and Hermes Enterprise, which companies self-host in their own Azure tenant as Foundry hosted agents. Nous has published an open-source cookbook on GitHub for self-hosting. Co-founder and CTO Jeffrey Quesnelle says the Enterprise version keeps learned skills "inside your tenant" while letting customers use any model provider. These are vendor claims, not independently tested results.

Internally, Microsoft says employees use more than 30 custom Foundry blueprints. It also runs an auto-approval path: agents that stay within limits agreed with Microsoft IT skip review. That's convenient for Microsoft. Most organisations should be slower to give themselves the same shortcut until their own guardrails are proven.

The verdict​

The real change here is not "AI agents are smarter now." It's that Microsoft has given agents an identity model that auditors can understand: who acted, whether they were authorised, and whether you can prove it later. The design is sound. Capability and access are separate, every agent has an accountable human manager, and a kill switch covers a whole fleet.

The costs are real, though. Each instance is a licensed account. Telemetry needs extra setup. Data residency changes when Agent 365 is involved. And everything is still tied to a preview program. If your organisation is testing it, start with one team-scoped blueprint, give it narrowly delegated access, and watch its audit trail before letting other teams hire their own copies.

 

References

  1. Build trusted autonomous agents for your team with Microsoft Foundry Microsoft Foundry Blog 2026-11-19T19:53:30+00:00
  2. Quickstart: Build your first autopilot - Microsoft Foundry | Microsoft Learn learn.microsoft.com
  3. What is an autopilot in Microsoft Foundry? - Microsoft Foundry learn.microsoft.com