What an AI agent at Microsoft is made of and where it runs.
An agent takes on a task, fetches knowledge and tools and acts in your systems; in Copilot Studio the business team maintains it, in Foundry it carries your code.
Click through the parts, the security rings and real cases, and watch an agent check an invoice, prepare a new starter or fend off an attack. This is how we design workflows AI-native: the agent does the work, and a person decides before every step with consequences.
Agent
Head · Reads, plans, writes
The model reads the request and plans the steps.
The language model understands the request, decides which tool comes next and writes the answer. We choose the model per task: a small one for sorting and summarising, a large one when the agent works with business systems and has to weigh options.
agent.yaml
model: claude-opus-5-5
fallback: smaller model, same tools
effort: medium
max_output: 2000 tokens
data: no training, per contract
region: per data sheet for each platform
How it is secured: Where the model runs is recorded per platform and model in the data sheet. Inputs and outputs pass through content filters, and the enterprise contract rules out training on your data.
On the platforms: Copilot Studio lets you pick the model per agent, Microsoft Foundry offers it from the model catalogue, and OpenAI and Anthropic provide their models through their own APIs.
Microsoft Foundry
Copilot Studio
OpenAI
Claude
01
Head, hands, memory and operations make up the agent.
An invoice arrives in the mailbox. The agent reads it, fetches the order from the ERP, compares items and amounts, proposes the account assignment and puts the discrepancy in front of a person for approval. For that it needs a head made of model, instructions and a soul file that records tone and limits; hands made of skills, tools and MCP servers with which it reads and writes; a memory for the case and for what it has learned about your workflows; and operations made of triggers that start it and evaluation that measures every version against the test set. The Agent Explorer above shows these parts, the security stations around them and four cases step by step, including the one in which a hidden instruction in a document is stopped. Before every step with consequences a person decides; that is the same for every type.
02
In Copilot Studio the agent that stays in Microsoft 365 is built.
The instructions say in your own words what the agent is responsible for and when it brings in a person; the generative orchestration plans with every message which topics, tools and knowledge sources it needs, and asks for missing details. SharePoint sites, Dataverse tables and connectors are attached as knowledge, connectors, prompts, MCP servers and computer use as tools; agent flows carry out steps that must run the same way every time and collect an approval on the way; triggers start the agent when an email arrives or a row is created. Since June 2026 the new authoring experience runs on the GitHub Copilot harness, with reusable skills and memory per person. Every new agent automatically gets an Entra Agent ID, through solutions it moves from the development to the production environment, and after handover the business team maintains it in the interface.
03
In Foundry Agent Service, prompt agents and hosted agents do the work.
A prompt agent is made of instructions, model and tools, and Foundry runs it without code of your own; voice-based prompt agents take calls. If a workflow needs its own logic or should wait for days at the point where a person decides, it runs as a hosted agent: your code in a container, with Agent Framework, LangGraph or no framework, with its own endpoint, an isolated sandbox per session and traces in Application Insights. The agent reaches tools through MCP servers that check its identity; a writing call runs through the workflow as an approval request and stands in the trace. Every change produces a new version, and only once it has passed the evaluation on the test set does it reach the endpoint. Through A2A agents talk to each other, across platform boundaries too.
04
Published to Teams and Copilot, listed in Agent 365.
From Copilot Studio as from Foundry the agent appears in Teams and in Microsoft Copilot, after approval by your IT for the whole organisation in the Agent Store; website, SharePoint and phone join as further channels, and it is maintained in one place. In the Microsoft 365 admin center the Agent 365 registry has listed every agent of the organisation since May 2026, from Microsoft, from partners, published by you or shared by individual people, with owner, status and signals from Entra, Purview and Defender, and a tile counts the agents whose owner has left the organisation. Next to the built agents stand the personal ones: Cowork takes a described task across several programs to the end, and Autopilot keeps working as a persistent agent with its own identity, memory and computer while the person sits in a meeting.
05
Several agents share the work, the test set the approval.
Beyond a certain size the task splits: an orchestrator hands out subtasks to specialists, a handover passes the case from one agent to the next, a checker reviews another agent's work before a person sees it, and parallel agents work on parts at the same time. In Copilot Studio an agent calls other agents as tools, in Foundry A2A connects them, and hosted agents bring the pattern in their own code. Which type fits is shown by the weighting in the explorer: a Teams agent lives in Copilot Studio, a process agent in the Agent Service, a personal agent as Autopilot, a coding agent in GitHub Copilot or Codex. The same route from task to operations applies to all of them: a pilot with one group, the test set as the approval, a named person who can stop the agent, and versions that go through evaluation.
What you decide.
Prompt agent or hosted agent?
Options
1A prompt agent made of instructions, model and tools
2A hosted agent with your code in a container
3An agent in Copilot Studio that calls a Foundry agent as a tool
Our recommendation: The prompt agent as long as instructions, tools and approvals cover the task: it is built fastest and handed over most easily. The hosted agent as soon as the workflow needs its own logic, waits long for a person or brings a framework your team knows. If employees should stay in Teams and the work behind it should happen in Azure, an agent in Copilot Studio calls the Foundry agent as a tool.
What we advise against: Writing code because developers are available. What a prompt agent carries needs no container that wants to be operated, versioned and patched.
What may the agent do without approval?
Options
1Only read and propose
2Read, propose and write in test systems
3Write with an approval per action with consequences
Our recommendation: Read and propose from day one; write with an approval before every action with consequences, that is before sending, posting, ordering and deleting, as an approval in Teams or Outlook or as an approval request to the MCP server. Which actions run without approval after a quarter without complaints is decided by the business team from the log, and deleting always stays with a person.
What we advise against: Approvals nobody reads. If every approval is waved through, a sample from the log replaces it better.
One agent or several?
Options
1One agent with every tool
2An orchestrator with specialists per subtask
3An agent and a checker
Our recommendation: One agent until its instructions become contradictory or its tool list too long; then specialists with one narrow brief each and an orchestrator that distributes. A checker pays off where a wrong answer is expensive, for instance with contracts and invoices: it gets the references, not the first agent's opinion.
What we advise against: Several agents as an organisation chart. Every additional agent needs an identity, a test set and a person who is responsible for it.
Who maintains instructions, tools and the test set?
Options
1The business team in the Copilot Studio interface
2The development team in the hosted agent's repository
3A partner who maintains both
Our recommendation: The business team maintains instructions, knowledge sources and the test set, because it knows the cases; the development team maintains tools, MCP servers and the code of a hosted agent. Every change produces a version that goes through the evaluation, and a named person may stop the agent at any time. We maintain both until your team takes over.
What we advise against: Instructions only one person understands. What is not in the repository or in the solution leaves with the person.
Status and sources.
As of: October 2026
As of 25 September 2026
Prompt, voice and hosted agents in Foundry, published to Teams and Copilot.
Foundry Agent Service offers prompt agents without code, voice-based prompt agents for phone and browser (preview) and hosted agents with your own code. Published agents appear in Microsoft Teams, Microsoft Copilot and the Entra Agent Registry. The A2A protocol 1.0 for agent-to-agent communication is generally available.
Copilot Studio automatically creates a Microsoft Entra Agent ID for every new agent; opting out at environment level is no longer possible. Connector permissions, Conditional Access and DLP policies therefore apply per agent.
Agents receive their own identities, created from a blueprint and with a person as sponsor. They sign in through OAuth and reach tools through MCP and other agents through A2A. Since May 2026 the list of all agents is kept in Agent 365 in the Microsoft 365 admin center; the identities stay in Entra.
In the Microsoft 365 admin center, the registry lists all agents available to your organisation: from Microsoft, from partners, published by your organisation and shared by individual people. A tile counts the agents without owners, for example after the person who created them has left; these can be blocked or deleted. Risk signals from Purview, Entra and Defender require a Microsoft 365 E7 or Agent 365 licence.
Microsoft introduced the new Copilot with Home, Code and Autopilot. Autopilot, previously called Scout, is a persistent, proactive personal agent with its own identity, memory, computer and workspace. Microsoft announced the private preview for the end of September.
This is how we put it into practice: the first agent in Copilot Studio with one business team, with fixed sources, permitted actions and a point where a person decides. Copilot Studio agents
Tone, stance and limits of the agent: how it talks to customers, what it never promises, when it brings in a person. In Copilot Studio that sits in the instructions field, in a hosted agent in a file in the repository. The business team writes it with us, on real cases; it steers the agent, while permissions and approvals draw the limits.
How does an MCP server reach the agent, and who approves it?
In Copilot Studio an MCP server hangs on the agent as a tool and runs through a Power Platform connector, so the data policies of your tenant apply to it; IT allows it per environment. In Foundry it is a tool of the agent, signs in with the agent identity or on behalf of the person, and we run a server of your own in your Azure subscription. A server you build once is open to both layers and to other platforms.
What happens with a hidden instruction in a document?
The agent reads it as data, not as an order: Prompt Shields in Foundry detect instructions in documents and tool responses, the approval halts every action with consequences, and the log shows the attempt. In Copilot, a preview excludes emails from external senders as a source. The case in the Agent Explorer above shows the sequence step by step until the agent stops.
Does every agent need an identity of its own?
Yes, and it is created on its own: since July 2026 Copilot Studio creates an Entra Agent ID for every new agent, Foundry for every published one. Connector permissions, Conditional Access and DLP policies hang on it, and if the identity is deactivated the agent receives no more tokens. Conditional Access for agents requires Microsoft 365 E7 or Agent 365 with at least Entra ID P1.
Where do we see every agent of the organisation?
In the Agent 365 registry in the Microsoft 365 admin center: every agent available to your organisation, with owner, status and signals from Entra, Purview and Defender, plus the agents without owners, which can be blocked or deleted. The identities themselves stay in Entra, and risk signals require a Microsoft 365 E7 or Agent 365 licence.
When is a hosted agent worth it?
When the workflow needs logic of its own that instructions and tools alone cannot express, when it should wait for days for a person, or when your team brings a framework such as Agent Framework or LangGraph. The container gets its own identity, an endpoint and a sandbox per session, runs in the Swiss regions, and every version goes through the evaluation before it goes live.
Is Autopilot an agent in the sense of this chapter?
Yes, the personal type: persistent, with its own identity in the tenant, its own memory and computer, set up by the person with a name, a role and a goal. Because it has an identity, the Entra policies and your IT's directive apply to it like to any other agent; Microsoft announced it as a private preview, and it puts results up for review.
Next chapter · Chapter 4
How AI reaches your data at Microsoft and what it sees.
How does AI reach our data at Microsoft, and what does it see?