Microsoft Certified: Azure AI Apps and Agents Developer Associate — Free Practice Questions
Free Azure AI Apps & Agents Developer (AI-103) practice questions, every answer explained. Covers Microsoft Foundry, RAG, agents and Content Understanding.
8 of the 15 questions in this set, with the correct answer marked and every option explained.
1. A developer needs to run a lightweight classification task inside an agent's tool pipeline where latency and cost matter more than broad general knowledge. Which type of model is the most appropriate choice for this task in Microsoft Foundry?
✓A small language model (SLM)
SLMs are purpose-built for narrow, latency- and cost-sensitive tasks like classification inside a larger pipeline -- they trade broad general knowledge for speed and lower cost, which is exactly the tradeoff this task calls for.
✗The largest available multimodal LLM
A large multimodal model is over-provisioned for a narrow classification task -- it costs more and responds slower than necessary when broad reasoning and multimodal input aren't required.
✗A code-generation model
Code models are optimized for generating and understanding source code, not for general classification tasks inside an agent pipeline.
✗A video-generation model
Video generation models produce video content from prompts; they have no relevance to a text classification task.
2. A team wants their Foundry application to call Azure AI services without embedding any API keys or secrets in application code or configuration files. Which approach satisfies this requirement?
✓Configure managed identity and keyless credentials for the application
Managed identity lets Azure resources authenticate to other Azure services without any embedded secret, and keyless credential flows extend that same principle to AI service calls -- directly satisfying 'no API keys in code or config.'
✗Store the API keys in environment variables inside the application container
Environment variables still embed a secret with the application's deployment artifact -- it's a different storage location, not the absence of an embedded key the requirement calls for.
✗Hardcode the API key directly in the source file
This is the least secure option and the direct opposite of a keyless approach -- the key is embedded in code and version control.
✗Share a single API key across all developers on the team
Sharing a static key doesn't remove the key from the application at all; it also weakens security by making the credential harder to rotate or attribute.
3. After deploying a RAG-based Foundry application to production, the team wants to be alerted if the retrieval pipeline starts returning less relevant results over time, and if the model's answers increasingly diverge from the grounding data. Which monitoring focus most directly addresses this?
✓Monitor search index health and relevance performance, and model grounding quality
This pairs the two specific failure modes described -- retrieval relevance degrading (search index health/relevance performance) and answers diverging from source data (grounding quality) -- with the exact monitoring dimensions that detect them.
✗Monitor only the Azure subscription's monthly billing total
Billing totals reflect cost, not retrieval relevance or how well answers stay grounded in the source data -- it wouldn't surface either failure mode.
✗Monitor only the number of concurrent users connected to the application
Concurrent user count is a load metric; it says nothing about whether retrieved results are relevant or whether generated answers are grounded in the data.
✗Disable monitoring once the application passes initial testing
Turning off monitoring removes the ability to detect exactly the kind of gradual drift described -- these regressions often only appear over time in production, after initial testing has already passed.
4. A company's compliance team requires that every response an agent gives can be traced back to which tools it called, what data it retrieved, and who approved any higher-risk actions it took. Which capability set addresses this requirement?
✓Auditing through trace logging, provenance metadata, and approval workflows
Trace logging records what the agent did and what it retrieved, provenance metadata attributes that data to its source, and approval workflows capture who signed off on higher-risk actions -- covering all three parts of the compliance requirement directly.
✗Increasing the agent's maximum token output
A larger output limit changes how much text the agent can generate; it has no bearing on traceability, provenance, or approval records.
✗Disabling content moderation to speed up responses
Turning off content moderation removes a safety control and has nothing to do with traceability -- it also directly conflicts with a compliance-minded deployment.
✗Reducing the number of tools available to the agent to exactly one
Limiting tool count doesn't create an audit trail by itself -- without logging, provenance metadata, and approval workflows, actions still aren't traceable.
5. A developer wants their Foundry application to answer questions using the organization's current internal documents, without fine-tuning the underlying model. Which technique should the developer implement?
✓Retrieval-augmented generation (RAG)
RAG retrieves relevant content from an external data source at query time and adds it to the model's context, letting the application answer from current internal documents without any fine-tuning of the model itself.
✗Fine-tuning the model on the company's entire document archive
Fine-tuning bakes a snapshot of the documents into the model's weights, requires retraining whenever documents change, and is explicitly what the requirement says to avoid ('without fine-tuning').
✗Increasing the model's temperature parameter
Temperature controls output randomness per request; it has no ability to ground answers in an organization's internal documents.
✗Reducing the number of tokens allowed in a response
Limiting response length is a cost/latency control; it doesn't connect the model to any external document source.
6. A developer is building an agent that must call an internal inventory API with a specific set of parameters and data types, and reliably parse the API's response back into its reasoning. Which agent-design element should the developer define to make this tool call reliable?
✓A tool schema that defines the function's expected parameters and return structure
A tool schema formally specifies what parameters a function call expects and what shape its response takes, which is exactly what lets an agent reliably construct valid calls and parse the results back into its reasoning.
✗A larger context window for the underlying model
Context window size affects how much text fits in a single request; it doesn't define how a tool's parameters or response structure are specified.
✗A higher temperature setting for more creative responses
Higher temperature increases output variability, which works against reliable, consistent structured tool calls rather than supporting them.
✗Disabling the agent's conversation memory
Conversation memory affects whether the agent recalls prior turns; it has no relationship to how a specific tool's parameters or response format are defined.
7. A workflow requires a research task to be broken into sub-tasks -- one agent searches documents, another summarizes findings, and a third drafts a final report -- with each agent specialized for its sub-task. Which architecture pattern does this describe?
✓Orchestrated multi-agent solution
This is a textbook multi-agent orchestration: distinct, specialized agents each handle one sub-task (search, summarize, draft) under some coordinating logic, rather than one agent trying to do everything.
✗A single agent with a very long system prompt
One agent with an elaborate prompt is still a single point of reasoning, not specialized agents each handling a distinct sub-task with their own scope.
✗Batch inference on a static dataset
Batch inference processes a fixed set of inputs offline; it isn't an interactive, coordinated set of specialized agents working a task together.
✗A single function-calling tool with no agent involved
A single tool call is one discrete action; it doesn't capture the coordination between multiple specialized agents that the scenario describes.
8. During evaluation, a team notices their Foundry application sometimes generates answers that sound confident and plausible but aren't actually supported by the retrieved source documents. Which evaluation focus specifically targets this failure mode?
✓Detecting fabrications (hallucinations) as part of model and app evaluation
Fabrication detection is the evaluation dimension built specifically for confident-sounding but ungrounded output -- comparing generated claims against the retrieved source content to catch exactly this failure mode.
✗Measuring only the response's latency
Latency measures how fast a response arrives, which is unrelated to whether its content is actually supported by the source documents.
✗Measuring only token cost per request
Token cost tracks spend, not factual grounding -- a cheap response can still be confidently wrong, and an expensive one can still be well-grounded.
✗Increasing the model's maximum output length
A longer allowed output doesn't address whether the content is accurate -- it could just as easily produce a longer ungrounded answer.
7 more questions in the app
Practise the full 15-question set with a timer, scoring and progress tracking.