Overview
This skill area covers custom agents: models that receive instructions, decide which tools to call, act, and keep working on a goal across several steps. You configure the resources an agent needs (a Foundry project, a model deployment, connections to data and tools), create single agents in the Microsoft Foundry Agent Service, and build more complex agents and multi-agent workflows with the Microsoft Agent Framework, the open-source SDK that succeeds Semantic Kernel and AutoGen for agent work.
The outline also asks you to handle orchestration across several agents, several users and autonomous behavior, then test, optimize and deploy. The exam's interest is design judgment: knowing what an agent adds over a single prompt or a RAG app, which built-in tool solves a step, where a human approval belongs, and how to prove an agent is choosing the right tools before it goes live.
How it's tested
Questions describe a business task and ask whether an agent fits, which tool or configuration an agent needs, or how to coordinate several agents. Expect BEST design choices, tool selection, short SDK snippets that create an agent or run, and questions about adding human approval or evaluation before deployment.
-
Agent or not
A task is described and you decide between a single prompt, a RAG app, a single agent with tools, or a multi-agent workflow. Multi-step goals that need actions or tool choice point to agents.
-
Tool selection
An agent must compute, search documents, reach the web, or call a business API, and you choose code interpreter, file search, Azure AI Search, Bing grounding, OpenAPI or function calling.
-
Orchestration and control
Several agents or users are involved and you choose an orchestration pattern, where state lives, and where a human approval step is required.
An agent must answer analysts' questions by running statistics on uploaded CSV files. File search would find text in the files but cannot calculate. Function calling would work only if you wrote and hosted the analysis code. Code interpreter lets the agent write and run Python in a sandbox over the uploaded files, which matches the need. Match the tool to the verb in the task: calculate means code interpreter.
Skill groups 1
Official skill groups from the Microsoft outline, in outline order.
3.1 Create custom agentsAgent use cases, resources, Foundry Agent Service, Microsoft Agent Framework, multi-agent workflows, testing and deployment.
- What it means
- An agent combines a model deployment, instructions and a set of tools, and keeps conversation state so it can plan and act over several steps. The Foundry Agent Service hosts agents with built-in tools such as file search, code interpreter, grounding with Bing Search, Azure AI Search, OpenAPI tools, Azure Functions and function calling. The Microsoft Agent Framework adds code-first agents and graph-based workflows that orchestrate several agents with patterns such as sequential, concurrent, handoff, group chat and Magentic.
- What to understand
- Function calling means the model asks your code to run a named function with arguments, your code executes it and returns the result, and the run continues. Conversation state is kept per user in threads (called conversations in the newer API), which is how one agent serves many users without mixing contexts. Autonomous or multi-agent designs need guardrails: least-privilege identities for tools, Prompt Shields for document attacks, human-in-the-loop approval for consequential actions, and agent evaluators such as intent resolution, tool call accuracy and task adherence.
- How it shows up
- A scenario describes a goal (triage tickets, research and draft a report, book travel with manager approval) and asks for the tool, the orchestration pattern, the state model or the control that makes it work safely.
- Common confusion
- Candidates assume the model executes a declared function by itself. With function calling, the agent only returns the function name and arguments; your application runs the code and submits the output back to the run.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Agent
An agent is a model plus instructions plus tools that can decide which actions to take and keep working toward a goal across several steps.
- Remember
- An agent is justified when the task needs tool choice, actions or multi-step planning; a single answer from known context is cheaper as a plain prompt or RAG call.
- Tested as
- Design questions test whether you recognize when an agent is overkill.
- Trap
- Building an agent for a fixed, one-step transformation such as summarizing an email.
-
Threads, messages and runs
In the Agent Service, a thread holds one conversation's messages, and a run executes the agent against that thread, calling tools as needed.
- Remember
- Create one thread per user conversation so state stays isolated; the newer Foundry API calls these conversations and responses.
- Tested as
- Snippets ask which object to create for a new user or what to poll for completion.
- Trap
- Reusing one thread for every user, which mixes their context and data.
-
Function calling
The agent returns a request to call one of your declared functions with JSON arguments, your code executes it and submits the output, and the run continues.
- Remember
- The run pauses in a requires-action state until tool outputs are submitted.
- Tested as
- Questions ask who runs the function and what the app must do next.
- Trap
- Expecting the service to run your function code automatically.
-
Code interpreter
A built-in tool that lets the agent write and execute Python in a sandbox, including over uploaded files, and return charts or files.
- Remember
- Choose it when the task requires calculation, data analysis or file conversion.
- Tested as
- Data-analysis tasks in agent scenarios point here.
- Trap
- Choosing file search for a task that needs computation.
-
File search vs. Azure AI Search tool
File search builds a managed vector store from files you upload to the agent; the Azure AI Search tool queries an index you already own.
- Remember
- Use the Azure AI Search tool when an enterprise index already exists with its own security and enrichment.
- Tested as
- Scenarios mentioning an existing search index or thousands of governed documents point to Azure AI Search.
- Trap
- Re-uploading an existing corpus into file search.
-
Grounding with Bing Search
A tool that lets the agent retrieve current public web information and cite it.
- Remember
- It is for public, current information; private data belongs in file search or Azure AI Search.
- Tested as
- Requirements for today's news or public prices point here.
- Trap
- Using Bing grounding for internal documents.
-
OpenAPI and Azure Functions tools
An OpenAPI 3.0 specification lets the agent call an existing REST API directly; an Azure Functions tool lets it trigger serverless code.
- Remember
- An OpenAPI tool needs a spec and an authentication method (anonymous, API key connection or managed identity).
- Tested as
- Integration questions ask how to let an agent call a line-of-business API with least effort.
- Trap
- Writing a wrapper function when the API already publishes an OpenAPI spec.
-
Microsoft Agent Framework
An open-source SDK for .NET and Python that combines the agent abstractions of Semantic Kernel and AutoGen with graph-based workflows.
- Remember
- Workflows connect executors and agents with edges, support checkpointing, and allow human-in-the-loop steps.
- Tested as
- Complex, multi-agent or code-first requirements point here rather than to a single portal agent.
- Trap
- Assuming complex orchestration must be built from scratch with raw API calls.
-
Orchestration patterns
Sequential passes work along a chain, concurrent runs agents in parallel and combines results, handoff transfers control to a specialist, group chat lets agents converse under a manager, and Magentic uses a planning manager for open-ended tasks.
- Remember
- Choose the pattern from how work divides: a pipeline is sequential, independent opinions are concurrent, routing to a specialist is handoff.
- Tested as
- Multi-agent scenarios describe the flow of work and ask for the pattern.
- Trap
- Choosing group chat for a strict step-by-step pipeline.
-
Human-in-the-loop approval
A workflow pauses before a consequential action and waits for a person to approve, edit or reject it.
- Remember
- Required wherever an agent spends money, sends external messages or changes records under policy.
- Tested as
- Scenarios with approval rules or compliance needs point here.
- Trap
- Relying on instructions in the system prompt to stop risky actions.
-
Agent evaluation
Agent evaluators score intent resolution, tool call accuracy and task adherence, alongside safety evaluators and tracing of each step.
- Remember
- Evaluate tool choice and arguments, not only the final text answer.
- Tested as
- Test-and-optimize questions ask how to verify an agent before deployment.
- Trap
- Judging an agent only by fluency or relevance of its final reply.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Single prompt vs. RAG app vs. single agent vs. multi-agent workflow
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Single prompt | One model call with instructions and input | Cheapest and most predictable; no tools or memory | Dismissing it for tasks it already handles |
| RAG app | Retrieve passages, then generate an answer | Fixed retrieve-then-answer flow; no action-taking | Calling it an agent because it uses search |
| Single agent | Model chooses and calls tools over several steps | Handles open-ended tasks with actions | Overloading one agent with many unrelated tools |
| Multi-agent workflow | Specialized agents coordinated by an orchestration pattern | Separates responsibilities; adds cost and complexity | Using it where one agent with two tools suffices |
Function calling vs. OpenAPI tool vs. code interpreter
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Function calling | Agent requests your code to run a declared function | Your app executes it and returns output | Assuming the service runs the function |
| OpenAPI tool | Agent calls a REST API described by an OpenAPI spec | The service makes the HTTP call directly | Forgetting the authentication setting |
| Code interpreter | Agent writes and runs Python in a sandbox | For calculation and file processing, not external systems | Using it to call business APIs |
Sequential vs. concurrent vs. handoff vs. group chat
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Sequential | Each agent's output feeds the next | Fixed pipeline order | Using it for independent tasks that could run in parallel |
| Concurrent | Agents work in parallel on the same input | Results are aggregated afterwards | Using it when steps depend on each other |
| Handoff | An agent transfers control to a specialist | One agent active at a time, chosen dynamically | Confusing it with sequential |
| Group chat | Agents converse in a shared thread under a manager | Collaborative refinement, such as writer and reviewer | Choosing it for strict pipelines |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Agent for everything
- What candidates pick
- Create an agent to classify each incoming email into one of five categories.
- Why it looks right
- Agents are the newest capability and sound more powerful.
- Why it's wrong
- Classification of a single input needs no tools or planning; a prompt or a trained classifier is cheaper, faster and more predictable.
Clue to watch for A single input, a single output and no action to take.
-
Service-run functions
- What candidates pick
- Declare the function in the agent and wait for the run to complete.
- Why it looks right
- Declaring the tool feels like enough for the agent to use it.
- Why it's wrong
- The run pauses with a requires-action status; your code must execute the function and submit the tool output before the run can continue.
Clue to watch for A run stuck waiting after the model decided to call a function.
-
File search for analysis
- What candidates pick
- Attach the sales spreadsheets with file search so the agent can compute quarterly growth.
- Why it looks right
- File search makes the files available to the agent.
- Why it's wrong
- File search retrieves text passages; calculation over tabular data needs code interpreter.
Clue to watch for Verbs such as calculate, chart, aggregate or convert.
-
Prompt-only guardrails
- What candidates pick
- Tell the agent in its instructions never to approve refunds above a threshold.
- Why it looks right
- Instructions are easy and usually followed.
- Why it's wrong
- Instructions can be ignored or overridden by injected content; consequential actions need an enforced approval step and least-privilege tool access.
Clue to watch for Financial, legal or customer-facing actions with a policy limit.
-
One shared thread
- What candidates pick
- Create one thread at startup and add every user's messages to it.
- Why it looks right
- It is simple and keeps all history in one place.
- Why it's wrong
- Users would see each other's context and data; each conversation needs its own thread.
Clue to watch for Many users or tenants talking to the same agent.
-
Group chat for a pipeline
- What candidates pick
- Use group chat for extract, then validate, then file.
- Why it looks right
- Group chat sounds like the general multi-agent option.
- Why it's wrong
- A fixed order where each step consumes the previous output is the sequential pattern; group chat adds cost and unpredictability.
Clue to watch for The word 'then' between steps that always run in the same order.
Answer framework
Use this sequence to design or troubleshoot an agent scenario on AI-102.
- Decide whether the task needs tool choice, actions or multi-step planning; if not, use a prompt or RAG app instead of an agent.
- Map each step of the task to one tool by its verb: search private data, search the web, calculate, call an API or run business code.
- Give each tool and the agent's identity only the access it needs, and isolate conversation state with one thread per user conversation.
- If several specialists are involved, pick the orchestration pattern from how work flows: pipeline, parallel, handoff or discussion.
- Add human approval for consequential actions, then evaluate intent resolution, tool call accuracy and task adherence with tracing before deployment.
Practice question
Want more like this? The AI-102 practice test has questions for every domain.
Checklist
0 of 11
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Start by building one agent in the Foundry portal with a model deployment and two tools: file search over a few documents and code interpreter. Ask it questions that need each tool and read the run steps to see which tool it chose. This makes threads, runs and tool calls concrete in an hour.
Next, recreate the same agent from code and add a function-calling tool. Handle the requires-action state yourself, submit the output, and watch the run resume. This is the most commonly misunderstood mechanic in the domain and a likely source of code-reading questions.
Then read the Microsoft Agent Framework overview and its orchestration patterns. You do not need to memorize the API surface, but you should be able to look at a described workflow and name sequential, concurrent, handoff, group chat or Magentic. Pair each pattern with one example from your own work.
Commonly underestimated areas are control and testing: human approval, per-user state, least-privilege tool connections and agent evaluators. Finish by running an evaluation on your agent and checking tool call accuracy. Afterwards, revisit Domain 2's evaluation and tracing topics, which the agent questions assume.
FAQ
How much of AI-102 is about agents?
Implement an agentic solution is weighted at 5-10% in the final AI-102 study guide, the smallest skill area. Agent concepts also appear in generative AI and responsible AI scenarios.
What is the difference between Foundry Agent Service and Microsoft Agent Framework?
The Foundry Agent Service is the hosted service where you create and run agents with built-in tools. The Microsoft Agent Framework is an open-source .NET and Python SDK for code-first agents and graph-based multi-agent workflows, and it can work with Foundry-hosted agents.
Does the agent run my function code?
No. With function calling, the model returns the function name and arguments, and the run waits. Your application executes the function and submits the result so the run can continue.
When should I use multiple agents instead of one?
When distinct responsibilities need different instructions, tools or permissions, such as a researcher and a reviewer. If one agent with a few tools can do the job, extra agents add cost and unpredictability.
How do agents serve many users safely?
Keep a separate thread or conversation per user, give tools least-privilege identities, and avoid sharing state that contains one user's data with another.
Is this domain worth studying given its low weight?
Yes, because questions are often quick to answer once you know the tools and patterns, and the same ideas carry into Microsoft's successor exam, AI-103, where agentic work is a much larger share.
How does this domain connect to responsible AI?
Agents read untrusted content and take actions, so Prompt Shields for document attacks, human approval for consequential steps, and safety evaluation from Domain 1 apply directly.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 3 knowledge
You have just reviewed when agents are justified, which tool fits each task, how function calling hands control back to your code, and how multi-agent patterns differ. Practice questions show whether you can make those calls quickly.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the AI-102 AI tutor Get any concept explained your way