Autopilots / Persistent Agents in Copilot Studio: Hands-On Test and Lessons

For the last few weeks I’ve been testing something in a private preview that Microsoft has now made public: agents in Copilot Studio that work like a colleague. They have their own account, start by themselves when something happens, and carry what they learned into the next run. Microsoft’s Copilot Studio blog from October 15, 2026, calls them persistent and proactive. I see them as Autopilots, just built as agents in Copilot Studio.

You send them an email and they pick it up in their own mailbox. They collect information, create documents, reach out to people in Teams, and post updates. You can @mention them in comments in Word, Excel, and PowerPoint, and they jump in. An incoming email or a fixed schedule is enough to start a run, no prompt needed.

What do these agents add?

What’s new is that an agent can get an account of its own and show up in your tenant as a member of the organization. Microsoft puts four pieces together for that:

Because the agent acts under its own account, Microsoft says you can tell what it did and what a person did. Admins govern and audit it like any other identity: they scope its access, add controls, and manage its lifecycle. Over the next few months, Microsoft plans to add recommendations for improving an agent based on its past runs. Later, agents are also supposed to get a browser-enabled cloud computer of their own for long-running work; Microsoft gives no timeframe for that.

What do I use these agents for?

The first one is “Daniel’s Chief of Staff.” It helps me summarize, streamlines my communication, takes orders from me, and posts into group chats with customers. The customers are guests in our tenant there. During the preview, the agent doesn’t respond to anyone outside it; that may still change.

The second one checks in with the team every Friday. I gave it skills for that: when the trigger fires, it sends the team a message in Teams, waits for their replies, pulls everything into a weekly summary for our manager, and posts it in Teams. Nobody has to chase anybody for updates anymore.

Microsoft Learn describes a similar setup: an agent that reads a tracker on a schedule, looks for blockers and missing updates, creates a new document, and sends reviewers the link. People still set the priorities.

How do you set up an agent with its own account?

The steps come from two Microsoft Learn pages, one on the account and one on triggers. Order matters: the account comes before your first publish. The video walks through steps 3 to 6 on my own agent, click by click.

What you see and hear: 46 seconds, no sound, screen recording in Copilot Studio. On the Build page, I select “Agent account” and confirm in the “Review account changes” dialog that Memory and the Microsoft Copilot trigger get turned on. Under “Create an agent identity,” I enter a name, email address, and job title and create the account. Then I show the six triggers that come with the account, add a “Recurrence” trigger with extra instructions, and open the pickers for skills and for tools like Outlook, Teams, SharePoint, OneDrive, Excel, and Dataverse. The agent's email address is blurred out.

1. Open the Copilot Studio preview and switch to an environment on the early release cycle.
2. Create a new agent, but don’t save it yet.
3. Under the agent’s name, select Agent account, then Add account. For tools that support it, the agent account becomes the default sign-in.
4. A dialog shows what changes on the agent. In my case, it turned on Memory and the Microsoft Copilot trigger. Select Continue and set the name and email address. The address starts with your own alias, and the agent reports to you. You can’t change either during the preview, and you can’t change the address after publishing, so decide on the name first.
5. Add a job title if you like, then select Create account.
6. Six triggers come with the account automatically: a chat in Teams, an @mention in a channel, an email arriving in the agent’s inbox, and an @mention in a document, spreadsheet, or presentation. Under Triggers, add anything else that should start the agent, for example a schedule for every Friday. Test each trigger with the flask button before you go further.
7. Select Publish. Only now does the account go live, with its mailbox, Teams presence, and directory entry.

Here’s what it looked like for me. First, Copilot Studio shows what changes on the agent:

Next, the agent gets its identity. I blurred out the full address:

Once the account exists, Triggers lists six triggers you don’t have to set up:

For a schedule, add the Recurrence trigger:

Instructions alone don’t create a schedule or grant access. What the agent can do comes from its triggers, tools, and permissions. For each tool, grant only the access the job needs.

What do you need?

As of October 15, 2026, this is a preview available only through the Frontier program. According to Microsoft Learn, you need:

• A tenant enrolled in Frontier, with the Microsoft Agent 365 terms of service accepted.
• An admin who has flipped two switches: activated the Copilot Studio agent template in the Microsoft 365 admin center (only the people and groups picked there can build these agents), and turned on Agent accounts for the environment in the Power Platform admin center.
• A maker license: Microsoft 365 E5 with the Microsoft Agent 365 add-on, or Microsoft 365 E7.
• A free “Microsoft 365 Frontier for AI Teammates” license for each agent. The agent takes one when you publish; if none is free, publishing fails.
• Copilot Credits for usage: building, testing, and running the agent can consume them. What a credit costs is in my post on Copilot pricing.

Before you sort out licenses and approvals, you can check for free whether your agent with its own account is feasible in Copilot Studio (in German).

One detail for Europe: in the European Economic Area, Teams is licensed separately from Microsoft 365. The agent still gets its account and mailbox, but it only shows up in Teams if your tenant licenses Teams separately.

You build agents with an account in the new Copilot Studio authoring experience that Microsoft calls the GitHub Copilot harness. It’s a framework inside Copilot Studio, not the GitHub Copilot service, and Microsoft says your data isn’t sent there.

What can’t the agents do yet?

Microsoft lists the limits plainly. Know these before you build a process on top:

• Nobody outside your tenant. The agent doesn’t respond to anyone outside it, and there’s no workaround in the preview.
• New documents, yes. Editing existing ones, no. It can generate documents but can’t co-author existing ones yet. As far as I know, that’s planned. In Office comments, it can’t make targeted edits either.
• No protected documents. It can’t read files with sensitivity labels like “Confidential” or “Internal Only.” Don’t strip the protection just to test the agent; use non-sensitive samples instead.
• Up to 250 people in an email conversation.
• Not all of Microsoft Graph. Some operations and permission scopes aren’t supported yet.

Who can see what the agent remembers?

This is where agents with an account differ most from regular agents. A regular Copilot Studio agent keeps a separate memory for each person, and nobody else can see it. An agent with its own account keeps one shared memory for everyone it works with, even in one-on-one chats. What one person explains helps the whole team.

Microsoft spells out what that means:

• Summaries of files and chats you share can show up in answers to other people, even people without access to the original, and regardless of sensitivity label.
• There’s no privacy boundary between users. The agent is told not to bring up one person’s details with someone else, but that’s guidance, not a lock.
• You can’t opt out during the preview, and an admin can only turn shared memory off by turning off agent accounts altogether.
• If nobody works with the agent for 28 days, the system deletes its shared memory.

Microsoft says it leaves out things like ID numbers, passwords, health information, judgments about anyone’s performance or conduct, and anything someone asks it not to remember. Still, only share what the whole team is allowed to know. The agent tells people this itself the first time they talk to it.

What about email?

An agent with its own mailbox can read and send email. My take from why your agent should never answer emails automatically still holds: an incoming email is untrusted content, and an agent that replies to anything from outside on its own is a risk. My Chief of Staff takes orders from me. The advice from that post still applies: if your agent acts in front of customers, decide up front who approves, and check the sender before a trigger fires.

My take

I’ll be honest: it’s really, really cool. Agents that live in the same inbox and chats as the team feel less like a tool and more like a colleague. With shared memory, you don’t have to explain the same thing every time.

In its example on Learn, Microsoft suggests starting with an approved source and a small internal group. My Friday agent for the weekly report stays inside my own team, too. If you want to plan a first agent like this for your tenant, with licenses, approvals, and memory, that’s what the coaching for IT and admins is for.

Sources

• Microsoft Copilot Studio Blog, October 15, 2026: Delegate shared business processes to agents that are more persistent and proactive with Microsoft Copilot Studio
• Microsoft Learn: Give your agent an account (Frontier)
• Microsoft Learn: FAQ for agent accounts (Frontier)
• Microsoft Learn: Add triggers to an agent (preview)
• Microsoft Learn: Memory (preview)
• Microsoft Learn: Agents powered by the GitHub Copilot Harness overview

All pages accessed October 15, 2026.