2026-11-17
Copilot Studio Document Agents - Simply Explained

Show notes
An invoice lands in your inbox, and a real person retypes every line. Microsoft Copilot Studio is the low-code studio where you build an assistant that can do that reading for you. In this episode of Simply Explained you will learn:
- What a document agent actually is
- Why there isn't one document agent button
- How the agent learns your documents
- Handing over a document right now
- Turning a document into structured data
- When the agent writes the document
- One invoice, end to end
- What it costs and where it breaks
- How it fits with Microsoft 365 and Azure
- What to remember, and one question for you
Simply Explained by M365.FM breaks down Microsoft 365, Azure and modern IT topics in clear, jargon-free language. Hosted by Mirko Peters. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.
Host: Mirko Peters
Guests
Transcript
Read the full transcript
Welcome to the M365 FM podcast, where we explore the people, ideas and technologies shaping the future of work. An invoice lands in your inbox and a real person retypes every line. Microsoft Copilot Studio is the low code studio where you build an assistant that can do that reading for you. You might think a document agent is just a chatbot about files, but it actually reads them, pulls out the details you name and hands back finished documents. You don't need to write code to build one, and you don't need to be an admin to understand how it works. Welcome to the M365 FM podcast, where we explore the people, ideas and technologies shaping the future of work. By the end, you'll know what a document agent is, where it sits between Microsoft three hundred sixty five and Azure and the limits that catch people out. What a document agent actually is. A document agent is an assistant that works on files. Instead of just chatting, you build it inside Microsoft Copilot Studio, which is a low code studio. So you assemble ready made parts instead of writing software from scratch. Microsoft describes every agent in Copilot Studio as a mix of three things. Generative AI works out what you're asking for. knowledge grounds the answer in your real content and actions. Let the agent do something. When a request needs more than a reply point, all three are documents and you have a document agent. The word agent sounds heavier than it really is. Think about the last time you opened a contract and hunted for the end date, or scrolled through a long PDF looking for one number on page nine. That slow, careful reading is the exact job a document agent takes over. It handles three jobs with documents. It reads a file and answers questions about it, and it pulls specific details out of a file and turns them into clean data. It can even build a brand new document for you, like a word report or a spreadsheet. Picture a small business that receives the same supply of form every week. Someone opens it, finds three numbers, and types them into a spreadsheet week after week. And that's the kind of task an agent can absorb. None of that asks you to write code. You set the agent up by pointing it at content and writing instructions in plain language. So this is a tool for beginners rather than a developers project. Keep in mind what it isn't to a document agent reads and reasons over documents, but it doesn't store them or replace your document library so your records still live where they always did. That matters because a huge amount of real work is still someone reading documents by hand. Invoices, contracts, policies, reports, and receipts all land on a person's screen and all of it eats time that could go somewhere better. So the real question becomes what you can actually build. And that starts with a choice most people don't know they're making. Why? There isn't one document agent button. There's no single button in Copilot Studio labeled Document Agent, which catches most people off guard. What you actually build is an agent and you aim it at documents. So the phrase describes a job rather than a product name you can buy. The reason comes down to engines, which Microsoft calls harnesses. An agent runs on one of four of them, and the one you pick changes what the agent can do and how it gets built. The GitHub copilot harness is the one built for heavy reasoning and long, multi-step work. Microsoft describes these agents as file ready, meaning they can create, edit, and reason over word, Excel, PowerPoint, and PDF files directly. If your job is document work, this is the harness you want. The other three cover different ground. The standard harness follows the rules and topics you define So it stays predictable. The copilot chat harness ads, your company's knowledge to Microsoft Copilot chat, and the customer conversation harness handles customers over voice and chat. Older copilot studio felt like a chatbot builder, and the newer experience works more like the AI assistants you already use. Topics gave way to skills which are small instruction files the agent picks up only when it needs them. The harness you pick also sets the ceiling on what your agent can do, so it's worth choosing. Deliberately. Use the standard harness for a predictable help desk and use the GitHub copilot harness when the work is genuinely about documents and reasoning. So when someone tells you they built a document agent, they usually mean an agent on the GitHub copilot harness with documents wired in as knowledge. That combination is the thing behind the name. How the agent learns your documents. Everything here comes down to how the agent knows what is inside your documents. That one detail decides whether it's useful or useless. The answer is knowledge sources, and the phrase is worth holding on to its content that you, the maker, connect once and from then on, every conversation with the agent can use it. That's a different thing from a file. A user drops into a single chat, which we'll get to in a moment. For document work, the main options are uploaded files SharePoint and OneDrive. You can upload PDFs, word documents, Excel files, and PowerPoint decks straight into the agent or pointed at a SharePoint site, a document library, or one specific file. The agent doesn't memorize your documents. It searches them when someone asks a question, then answers using what it found. So people call this grounding. Grounding simply means the answer stands on your content instead of the model's general knowledge. There's a switch worth knowing about called allow ungrounded responses. Turn it off, and the agent only answers when it can point to a source that's safer, but it can make the agent say it found nothing when it actually has the right answer, but no citation to show for it. Microsoft also shares a small practical tip that surprises people clear descriptive document titles help the agent find the right file. Because the title is one of the signals it uses to choose content. A file called final V three new PDF is harder for the agent to surface than one called contoso. Vendor agreement twenty twenty six PDF. Beyond files. An agent can also draw on structured business data. Dataverse tables, Azure SQL, and connectors to services like ServiceNow or Jira can all act as knowledge, so an agent can mix a policy document with a live record in the same answer. Start small here. One folder of policies is a better first knowledge source than a sprawling site, because a tight set of relevant documents keeps the answers on target. Handing over a document right now. Sometimes you don't want to add a document to the agent at all. You just want to ask about one file once. That's what attachments are for. A user attaches a file to a message and the agent reads, summarizes or reasons over it for that turn. The supported types include Excel images, PDF, PowerPoint, plain text files, word documents, and even a public web link. The distinction from knowledge sources is simple an attachment is per turn and belongs to one conversation, while a knowledge source is set up by the maker and applies to every conversation the agent ever has. A good example is a quick contract check. Someone drops a supplier contract into the chat and asks what the renewal date is, or attaches a screenshot and asks what the error message says. there are limits to keep in mind. Each file can be roughly sixteen megabytes. The agent keeps attachments for twenty eight days after the last activity in the conversation, and a web link has to download within 30s or it gets skipped for that turn. The practical upshot is that you get an answer about a specific file without anyone having to upload it, file it, or wait for an index to catch up. Attachments are the fastest way to test whether a document agent is worth building. You can try one inside a chat before you wire up anything permanent, which takes most of the risk out of a first experiment. Turning a document into structured data. Reading a document is useful. Pulling exact details out of hundreds of them is where the time savings pile up. That job belongs to a building block called the extract node. You tell it which values and tables you want, and it processes a document and returns them. Microsoft lists the document types it handles as invoices, contracts, reports, receipts, bank statements, and financial statements across PDF, word, Excel, and PowerPoint files. You set up the fields in one of three ways. You can upload a sample document and let the node suggest the fields start from a template for a common document type or add fields yourself and name them clearly for repeating information like the line items on an invoice, you use a list field so the node returns every row. You also choose the model that does the extraction. A more capable model helps when documents are long or the tables are messy, and a faster model works when the format is consistent and you're processing at volume. Microsoft's advice is to test the model on real documents before you publish the workflow. Microsoft's guidance on when to use it deserves repeating. Use the extract node when the goal is document focused extraction into a defined structure, and reach for a full agent node. When the workflow needs broader reasoning tools or a longer chain of steps. The point of all this is structure. Once an invoice becomes a set of named values, later steps can create a record, send a message, or make a decision. Because the document has turned into something a system can read. Think of the extract node as a translator. A document goes in on one side and clean, predictable data comes out the other, ready for whatever the next step in the workflow needs to do. When the agent writes the document, documents flow the other way too. And this is the part people don't expect a modern copilot studio agent can create files as the outcome of your request. Microsoft calls these files the agent creates, and they're still in preview. When your request naturally produces a file, the agent makes one and hands it back with a download card. That could be a report, a spreadsheet, an image, or a code snippet. It can also take a file you attached, edit it and return an updated version. You don't configure this behavior. It happens when the work calls for it, so it can feel like a small surprise the first time the agent answers with a document instead of a paragraph. The easiest way to see this in action is to ask for something you would normally build by hand, like a one page summary of a meeting, and watch what comes back. The limits are simple enough. A created file can be up to ten megabytes, and it lives in the conversation for the same twenty eight days as an attachment. If the agent's work would produce something bigger, you ask it to split the output into smaller pieces so the same tool reads documents, pulls data out of them, and writes new ones. That range is why document work fits an agent so naturally, and why the label keeps turning up one invoice end to end. Consider one job. You can picture an invoice arrives at a small business as an email attachment. Today a person opens. It, reads the invoice number, the vendor, the dates, the total, the tax, and every line item then types all of that into a system that's a slow, repetitive task with almost no judgment in it, which makes it a good candidate for an agent. Microsoft names this exact scenario in a workflow. An extract node receives the invoice and returns the invoice number, vendor details, dates, total amount, tax information, and line items. A later step then creates a record or routes the invoice for approval. When the total crosses a threshold, you set. What makes this a good first project is that the documents are boring. The same invoice layout arrives again and again, which is exactly the kind of consistency and extraction step handles. Well. A pile of wildly different documents is a much harder place to start. The same pattern covers other document jobs. Microsoft describes a workflow can process email attachments, route a contract or a report for review or pull values from reports that arrive in a consistent format. Now add the knowledge side. A document sitting in SharePoint gets its details identified, and a condition sends it to the right approver while updating its information along the way. What changes is the shape of the work? Instead of reading every line, the person reviews the fields the agent pulled out and decides whether they look right, which is faster and far less tiring than doing the same reading twice. Here is the honest part the agent proposes, and the person still approves for anything with money or legal weight attached. That human check isn't a flaw in the design, it's the design. What it costs and where it breaks. Building an agent is free and running one isn't. Copilot studio charges through copilot credits. The maker license costs nothing, so you can build without paying. Every action the agent takes draws credits though, and the meter runs at one cent per credit on the pay as you go plan. If you buy capacity packs instead, you pay two hundred dollars a month for twenty five thousand credits. That works out to about eight tenths of a cent each, and a pre-purchase plan can save up to twenty percent more. The same agent can cost wildly different amounts depending on how it's built. Scripted topics draw the fewest credits, generative answers draw more and autonomous actions that decide and act on their own. Draw the most. Microsoft changed the billing unit from messages to credits in September of twenty twenty five, so an older pricing guide is talking about the same money under a different name. If your organization already pays for Microsoft three hundred sixty five copilot at thirty dollars per user per month, that license covers the standard harness for internal agents using agents in copilot chat teams or SharePoint for classic and generative answers doesn't draw down your credits. The standalone Copilot Studio license is what unlocks the document heavy GitHub copilot harness and publishing to outside channels. Then come the edges and their firm. You can't index a document that's password protected or carries a confidential sensitivity label, and those files can look ready while quietly returning nothing. You can't ask which file mentions a topic, so questions about what exists in a folder go unanswered. A few more limits are worth knowing. A SharePoint source has a ceiling of twenty five side links under generative orchestration, and without a Microsoft three hundred sixty five copilot license in the same tenant, answers only reach SharePoint files under seven megabytes. Each agent also caps at five hundred. Knowledge sources so a sprawling library can hit a wall. One more piece of the money picture matters here. Copilot studio enforces your purchased capacity. Each month, an unused credits don't roll over to the next month. If you go past what you bought, Microsoft can technically enforce the limit, so it pays to watch usage before a surprise arrives. Experience builders run into the same handful of traps, and they're worth hearing before you start testing. Only in the built in test pane gives you false confidence, because real users ask messier questions than you do. Long, sprawling instructions confuse the model. Vague tool names make the agent pick the wrong one, and piling on custom code to control every step usually makes the agent worse rather than better. The most common trap is assuming the agent reads your files automatically when each knowledge source actually has to be indexed and refreshed after it changes. The practical move is to start on the pay as you go meter, measure a full month of real traffic, and only then decide whether a capacity pack saves you money. How it fits with Microsoft three. Sixty five and Azure. Zoom out and you can see where this sits. Copilot studio is part of the power platform, the family that also holds Power apps, Power Automate and Power BI. And that placement is what lets an agent reach Microsoft three hundred sixty five content like SharePoint, OneDrive, and teams. Publishing is where you decide who meets the agent. You can put it in Microsoft Teams, inside Microsoft Copilot, or on a web chat page. The standalone license is what lets you push it out to external channels, like a public website or a social platform for employees who already have Microsoft three. Sixty five copilot. The simplest path is the copilot chat harness because the agent shows up where people already work instead of asking them to visit somewhere new, Azure shows up in two places. Pay as you go billing runs through an Azure subscription linked to your environment. So the meter you saw earlier lives in Azure, as you are also backs the deeper data options such as grounding an agent in a knowledge base built in Azure AI foundry, or connecting it to Azure SQL as a knowledge source. Governance stays lighter than you might fear, at least from a beginner's point of view. Since July of twenty twenty six, Copilot Studio gives every new agent a Microsoft Entra Agent ID automatically, which is how administrators keep track of which agents exist and what they're allowed to touch. This isn't a separate island you have to learn from zero. If you already work in Microsoft three hundred sixty five, a document agent is one more thing you can build on top of what you own. What to remember. And one question for you. The simple version is worth repeating. A document agent is an assistant you build in Copilot Studio that reads your documents, answers questions about them, pulls specific details into clean data, and can hand you back a finished file. You assemble it from a harness, some knowledge sources and clear instructions, and you can put one together without writing code. It isn't free to run because every action draws copilot credits, and it has firm edges like refusing to index password protected files and struggling with questions about which file mentions what. That doesn't have to stop you, it's just the nature of the tool. So here is one question to take with you. If you could hand one document in your work to an agent tomorrow, which one would it be? If this made the topic feel less intimidating? Subscribe to M365 FM to master the tools and the mindset shaping the future of work.