Microsoft Foundry Agent Service - Simply Explained

0:00 Microsoft's Foundry catalog now holds more than ten thousand AI models. That number only matters if you can turn a model into something that actually does work. You might assume that means hiring developers and setting up servers. Foundry agent service is how Microsoft lets you build those working agents without the server headache. 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 it is, how it works, and whether you could use it. What an AI agent actually is. Start with the thing you already know because it makes the rest of this easier. A chatbot waits for your question, gives you an answer, and then stops right there. An agent takes your request and keeps working so it can look something up. Change a record, and then tell you what it did.

0:40 Picture a helper who handles your travel booking for you. You say you need a trip next month and the helper checks your calendar, finds a flight, books it, and sends you the details. A chatbot would only describe how to book that flight while an agent goes ahead and books it. Plane automation is different again, and it's worth keeping the two apart. Automation follows a fixed set of steps every single time, so it breaks the moment something unexpected happens. An agent decides which step to take next based on whatever it finds along the way, which is why it holds up better when the real world gets messy. If that sounds like a small difference, think about how much of your day disappears into chasing things down. Someone asks for an update and you open three systems to answer. An agent can do that opening and checking for you, and then hand you the answer with the work already done.

1:22 Every agent needs three simple parts. The first part is a model, which is the AI that reads your request and decides what to do next. The second part is instructions, which act like a job description and tell the agent what it is for. The third part is tools, which are the ways the agent can act, such as searching the web or updating a record. Put those three parts together and you get something that can work through a task in several steps instead of stopping at one reply. That's the whole idea behind every agent you'll meet today, no matter how big the name sounds. The model, it turns out, is the easy part. Everything around it is where the real work lives, and that idea comes back in a few minutes. What Microsoft Founder Agent service is. Now let's put a name on the product. Microsoft Foundry is the platform, and Foundry agent service is the part of it built for creating and running agents.

2:04 It lives in Azure, which is simply Microsoft's cloud, the place where companies rent computing power instead of buying and maintaining their own machines. The name is a small clue as well. A foundry is a place where raw material goes in and finished. Things come out, and that's roughly the idea here. Models and tools go in and working agents come out the other side. The word that matters most here is managed. When something is managed, Microsoft looks after the servers, the scaling and the updates. So you spend your time on the agent instead of on the plumbing. You still pay for what you use, but you don't sit up at two in the morning restarting a machine. That single word explains why a beginner can get something. Working in an afternoon foundry also meets you at whatever level you're comfortable with. At one end, you build an agent with nothing but settings and plain written instructions, which means no coding at all.

2:47 At the other end, you bring your own code and your own framework and foundry runs it for you. You can start at the simple end and move toward the code end later without throwing away what you built. There are three kinds of agent to know about, and the names are friendlier than they look. A prompt agent is built from settings and instructions, and it's the fastest place to begin. A voice agent is built for spoken conversations, so it can answer on a phone line or in a browser. A hosted agent is your own code, packaged up and run by foundry, with the servers and the scaling handled for you. Most people start with the first kind and never need the other two, which is perfectly fine. Underneath all three, foundry brings agents, models, and tools together in one place with shared access control and shared monitoring. In practice, that means one place to sign in, one place to set permissions, and one place to watch what your agents are doing.

3:32 That matters. Later, when you want to know who can touch an agent and what that agent has been doing. Models the brain. You can swap. Every agent runs on a model, and the model is the part that does the thinking. Think of it as the brain of the agent because it decides what to say or do while the tools handle the acting. The scale here is bigger than most people expect. The foundry catalog offers more than ten thousand models built by Microsoft, OpenAI, anthropic, meta, and plenty of others. Having that many options sounds overwhelming, but you don't have to shop around for long, because you can start with a sensible default and change your mind later. The useful part for you is that you can swap the model without rewriting your agent. If a cheap, fast model does the job, you use that one. If a harder task needs a stronger model, you change a single setting and keep everything else exactly as it was that freedom matters because it means you aren't locked into a choice you made on day one.

4:21 Different jobs suit different models in the same way that different errands suit different vehicles. A quick reply is a small errand, and a long chain of careful reasoning is a big one. The model you pick should match the weight of the task in front of it. The catalog also spans a wide range, from tiny models that cost almost nothing to large ones that reason through hard problems step by step. You don't need to memorize any of it, because the point is simply that you have options and you can change your mind without rebuilding the agent. So you have a brain you can swap, and that's genuinely useful on its own. The trouble is that a brain can't lift a finger by itself, and that gap is exactly what the next part fills. Tools and knowledge. How agents take action. A model on its own can only talk, and talking isn't the same as doing.

5:01 To do real work, an agent needs tools and a tool is simply a capability the agent is allowed to use. If the model is the brain, the tools are the hands. Foundry ships with built in tools that you can switch on. Web search looks things up. File search reads your documents and a code interpreter runs calculations and small programs. Memory is the forth and it lets the agent hold on to useful details between conversations. These all come ready to use so you get real value before you connect anything of your own. You aren't limited to those because you can add your own tools too. You can connect a tool through a function, through an open API definition or through MCP, which is a shared plug standard that lets AI tools connect to other systems. The exact labels matter less than the idea, which is that your agent can reach the systems your business already runs on.

5:44 Knowledge is the other half of the story. You can point an agent at your own content, such as files in SharePoint, data in Microsoft Fabric, or current results from Bing Search. When an agent answers from your real data instead of guessing. That's called grounding. And it's the difference between a confident answer and a correct one. One more piece is worth knowing, and it's called a toolbox. A toolbox lets you gather your tools once, expose them through a single connection, and reuse them across many agents with shared sign in and shared controls. It saves you from wiring the same tool into every new agent you build. To make this concrete picture an agent that helps onboard a new employee. In one request, it could pull the onboarding guidance from a knowledge base, create the account, draft a welcome email, and post a message in the team's channel.

6:26 That's several tools and several systems working together behind a single request. And it's the moment an agent stops being a novelty and starts being genuinely useful. Now you can see why the model was the easy part. The work sits in the tools, the data, and the permissions around them, and a toolbox is Microsoft's way of making that work. Manageable threads, runs, conversations and responses. Memory is what makes an agent feel less like a search box and more like a colleague, and it comes down to a few terms that used to confuse everyone. The good news is that those terms are getting simpler, so this part is easier than it sounds. In the older way of doing things. A conversation was called a thread. A thread held your messages, which were the back and forth between you and the agent. Each time the agent took a turn, that was called a run, and you could watch the run move from waiting to working to finished.

7:09 The new away keeps the same idea and changes the names. A conversation now holds the history and a response is what the agent produces, which can be an answer or an action. So threads became conversations and runs became responses. And that's the whole rename in a single line. The change does more than tidy up the wording. A conversation can store more than messages because it can also keep track of the tools the agent called and what those tools returned. The agent ends up with a richer memory of what happened, which makes it better at picking up where you left off. History matters for a practical reason. Most useful tasks take more than one message, and an agent that forgets the first half of a request isn't much use to anyone. Keeping the conversation lets the agent follow a thread of thought across many turns the way a person would.

7:49 You felt this in every good chat tool you've used, you ask a follow up question without repeating yourself, and the tool understands because it kept the earlier turns in view. Conversations give an agent that same ability, which is why they sit at the center of how it works. One practical note, since you may have read older guides, the old threads and runs setup is being retired in favor of this newer one. So if you're learning today, learn the words, conversation and response. That's where the platform has moved. Hosting and scaling. Where the agent lives. An agent has to run somewhere and that somewhere has to stay available when people actually use it. That's what hosting means. And it's one of those jobs you'd much rather hand to someone else for a prompt. Agent hosting is barely a topic at all. Microsoft runs it for you, so there's nothing to install, patch, or restart.

8:31 You write the instructions, choose the tools, and the agent is simply there when someone calls it hosted agents need a little more explanation because you're bringing your own code. Foundry runs that code in its own isolated space for each session, which is a tidy way of saying that one person's work stays separate from everyone else's. When more people use the agent, it scales up on its own, and when fewer do, it scales back down. The idle behavior is worth pausing on because it answers the cost question. When nobody is using an agent, it goes to sleep and its state is kept safe. When the next person arrives, it wakes up exactly where it left off, and you aren't paying for the quiet hours in between. Every hosted agent also gets its own identity and its own address automatically, and that sets up the next part of the story.

9:11 That identity is how the agent proves who it is when it reaches for your systems. One more detail is worth knowing, even if it stays invisible to you. Hosted agents run in a long list of Azure regions around the world, so a company can often keep its agents close to where its data already lives. For the audience here, the short version is that scaling is a problem the platform has already solved for you. Safety, identity and evaluation. Once an agent can reach into your systems, trust becomes the whole game. And this is where Managed platform earns its place. Start with identity. Every agent can get its own sign in, which means it only touches the things you've allowed and nothing else. You can also see what it did so an agent stays accountable in a way a shared password never could. Guardrails are the second layer.

9:52 These are built in filters that help block unsafe output. They also reduce the risk of someone tricking the agent through a prompt, which is the practice of slipping hidden instructions into something the agent reads. You can also keep an agent inside your own private network so its data doesn't wander anywhere you haven't approved. Evaluation is the part that surprises people because it works a lot like testing. Foundry includes checkers that score. Whether the agent finished the task, whether it followed your instructions, and whether it used the right tools along the way. You can think of them as unit tests for an agent, and they run before real people have to depend on it. Observability is the last piece, and it simply means you can trace every step the agent took. When something goes wrong, you follow the trail instead of guessing. And that's how confidence builds over time.

10:33 None of this means you can switch off your own judgment. A managed platform gives you the controls, but you still decide what an agent is allowed to do and how far it's trusted. The sensible approach is to start with a small, low risk task. Watch how the agent behaves and widen its reach only as your confidence grows. When an agent is ready, you can publish it to Microsoft Teams and Microsoft three hundred sixty five copilot, so people meet it in the tools they already use every day. That's what separates a clever experiment from something your team actually relies on. How it relates to Copilot Studio. By now, a fair question is forming because Microsoft has more than one way to build an agent and the names start to blur together. Let's clear that up. Copilot studio is the low code door. It's built for business users and makers, and it connects quickly to the Microsoft three hundred sixty five tools and power platform connectors your company already owns for many teams.

11:18 It's the fastest route to a working agent. If your goal is a helpful assistant. Inside teams, this is usually where you start. Foundry is the Pro code door. It gives you control over the model, over your own data, and over complex setups where several agents work together. When a job needs custom logic, a specific model, or serious scale, this is the door you walk through. These are two doors into the same house, not rivals. Many teams start in Copilot Studio for a quick win and reach for foundry. When the requirements grow. The two can even work side by side, with one handling the conversation and the other doing the heavy lifting. They also share a governance story. Both sit under the same Microsoft identity and data controls, so your security team keeps one way of watching over agents instead of two. They even live on the same underlying platform, which is why the skills you learn in one carry straight over to the other.

12:01 The practical takeaway is simple, so start light and scale when you genuinely need to. What people actually build with it. It helps to see what this looks like inside a real company, because a few patterns show up again and again. Customer support shows up first, where an agent connects to the system that holds your customer details, known as a CRM, and handles common questions in real time. Routine work is another where an agent schedules meetings, sends reminders, and generates reports. So people stopped doing it all by hand. Then there's the quieter win, where an agent reads current data and comes back with an insight or a recommendation. Real examples are easier to picture than categories. BMW uses multi-agent AI, so its engineers get insights from vehicle measurement data that they can act on right away. KPMG works in a regulated industry, and it leans on the governance and observability in the platform so its agents stay accountable.

12:47 The same patterns turn up across industries from a bank handling routine account questions to a manufacturer pulling insight out of machine data. The details change, but the shape of the work stays the same. Then there's the money question, and the answer is friendlier than you might expect. Microsoft doesn't charge extra for creating or running foundry native agents with prompts and workflows. you pay for the model usage behind them, and for the tools and data you connect, which means the cost follows the work the agent actually does. Recap. And one question for you. Let's pull this together quickly. An agent is a model plus instructions plus tools. And it can carry a task through several steps rather than stopping at one reply. Microsoft Foundry Agent Service is the platform that handles the parts around the model, including the tools, the memory, the identity, the hosting, and the checking of the work.

13:32 You can start with no code and grow into code when you're ready. Copilot studio is the low code, DAW and foundry is the Pro code DAW and both lead into the same house. The thing worth carrying away is this the AI brain was never the hard part because everything around it was. And that's exactly what the platform takes off your plate. So here is my question for you, and I'd love to hear your answer. If you could hand one task to an agent tomorrow, what would you hand over first and what would you want it to leave alone? If that question got you thinking? Leave your answer in the comments and subscribe to the M365 FM podcast for more. Simply explained episodes that make this world a little less intimidating.