AI-103 Developing AI Apps and Agents on Azure Exam Topics and Questions

This topic sets the foundation for everything else on the exam. Before you write a line of code or deploy a model, you need to have made the right architectural choices: which Foundry services belong in the solution, which model fits the task, how the infrastructure is shaped, and how the whole system stays secure, observable, and compliant. Get these decisions wrong on paper and you pay for it across every other topic.

– Selecting models, services, and retrieval approaches

The exam expects you to match workload characteristics to the right model category. Large language models, small language models, multimodal models, and the tooling available through Foundry each have different cost, latency, and capability profiles. Picking the wrong one is a design error, not a configuration error, and items will test that distinction. Alongside model selection, you need to know which Foundry services apply to generative tasks versus grounding versus agent workflows versus multimodal processing. Retrieval and indexing choices sit here too: understanding when vector search is appropriate, when hybrid search is better, and what indexing strategy feeds a grounding pipeline cleanly. Memory, tool, and knowledge integration services for agent solutions round out this cluster. The underlying question across all of it is whether your choice is justified by the task requirements, not just whether it works in isolation.

– Infrastructure, deployment, and CI/CD

Designing Azure infrastructure for AI apps and agent-based solutions means reasoning about network topology, compute placement, and service dependencies before deployment. Items in this area will push you toward or away from specific deployment options based on constraints in the scenario: latency, data residency, throughput, or cost. Configuring model and agent deployments is distinct from choosing them, so expect questions that focus on the settings themselves rather than the selection rationale. Integrating Foundry projects with CI/CD pipelines is a practical concern that shows up here: the exam treats it as an engineering discipline, not an afterthought. Managing quotas, scaling, rate limits, and cost footprints for model and agent workloads belongs in this cluster because those controls are set at deployment time and have direct consequences when a production system hits a limit.

– Monitoring, observability, and performance

Three distinct monitoring concerns appear in the sub-topics and the exam does not treat them as interchangeable. Model performance, drift, and safety events are one concern. Grounding quality is a second, and it requires you to think about how retrieved content affects generation output. Data ingestion quality, search index health, and relevance performance are a third concern that lives upstream of inference. Candidates who conflate these areas struggle with scenario items that describe a symptom and ask for the right monitoring response. Knowing which signal belongs to which layer of the stack determines which answer the item rewards.

– Security, responsible AI, and governance

Security configuration for AI solutions on Azure covers managed identity, private networking, keyless credentials, and role policies. Each of these has a preferred pattern in the context of Foundry and agent workloads, and the exam will present alternatives that look reasonable but introduce unnecessary risk. Responsible AI in this topic is operational, not philosophical. You are configuring safety filters, guardrails, and content moderation; applying evaluators and safety evaluations; implementing trace logging and provenance metadata; and governing agent behavior through oversight modes and tool-access controls. The approval workflow sub-topic is worth attention: it sits at the intersection of responsible AI and agentic autonomy, and items here test whether you know when human-in-the-loop controls are required versus optional.

How Plan and manage an Azure AI solution is tested

This is the largest topic on the exam and its items span the widest range of cognitive demand. Some items present a scenario with explicit constraints and ask which service, model, or configuration satisfies all of them. Others describe a running system and ask what is wrong with its monitoring or security posture. The trap in service-selection items is that multiple options are technically valid and the item rewards the one that best fits all stated constraints, not just one of them. Responsible AI items are particularly exacting: they expect you to know which control addresses which risk, so a general answer about safety filters will not score where the scenario calls for provenance metadata or an oversight mode. Monitoring items reward candidates who can map a described symptom to the correct layer of the stack. Preparation that drills you across the full breadth of this topic, rather than focusing on one cluster, is what protects your score here.

Where the first topic asks you to plan and choose, this one asks you to build and operate. The shift matters because implementation items test hands-on reasoning: given a Foundry SDK, a model deployment, and a stated requirement, what do you actually configure? This topic covers the full build cycle from a single LLM call through to a monitored, multi-agent production system, and the sub-topics are dense enough that a surface-level review of any one area will leave you exposed.

– Building and evaluating generative applications

Deploying and consuming LLMs, small models, code models, and multimodal models through Foundry is the baseline skill this cluster tests. Retrieval-augmented generation sits here too, and items will test your understanding of how the retrieval step feeds the generation step, not just that RAG exists as a pattern. Designing workflows that include tool-augmented flows and multistep reasoning pipelines requires you to think about sequencing and dependency, not just individual model calls. Evaluation is a distinct sub-topic: detecting fabrications, assessing relevance, measuring quality, and checking safety are separate concerns and the exam treats them that way. Integrating generative workflows into applications via Foundry SDKs and connectors, and configuring an application to connect to a Foundry project, are the practical wiring tasks that items will test through scenario-based questions where one configuration detail is wrong.

– Building and integrating agents

Agent construction on Foundry has specific moving parts: role definitions, goal framing, conversation-tracking approach, and tool schemas. Items in this area will test whether you understand how those parts interact, not whether you can recite their names. Building agents that integrate retrieval, function-calling, and conversation memory is a multi-concern problem because each of those capabilities has its own configuration surface. Tool integration is broad: APIs, knowledge stores, search, content understanding, and custom functions are all named, and the exam will distinguish between them in scenarios. Autonomous and semiautonomous workflows with safeguards and approval flow controls appear here and connect back to the responsible AI governance sub-topics from the first topic. Monitoring deployed agents, evaluating agent behavior, and performing error analysis close the loop: building an agent without observability is an incomplete solution and the exam will penalize that gap.

– Optimizing and operationalizing generative AI systems

Prompt engineering and adjusting model parameters to tune generation behavior is one area; model reflection, chain-of-thought evaluations, and self-critique loops are a separate, more advanced area. The exam distinguishes between them because they address different problems. Observability through tracing, token analytics, safety signals, and latency breakdowns is the operational layer that sits on top of a running system, and items will test whether you know which signal to examine for which symptom. Orchestrating multiple models, flows, or hybrid LLM and rules engines is the most architecturally complex sub-topic in this cluster. It requires you to reason about how components hand off to each other, where latency accumulates, and how failure in one component affects the rest of the pipeline.

How Implement generative AI and agentic solutions is tested

Items in this topic are predominantly scenario-based and require you to reason about a system in a specific state. A common pattern presents a partially built agent or generative application and asks what is missing, misconfigured, or likely to fail. The evaluation sub-topic is a consistent source of difficulty: candidates who treat fabrication detection, relevance, and safety as a single undifferentiated concern will pick answers that are in the right direction but not specific enough. Agent items reward candidates who understand the interaction between conversation memory, tool schemas, and retrieval, because the wrong combination produces coherent-looking output that fails on closer inspection. Optimization items are tricky because both prompt engineering and chain-of-thought reflection can improve output quality, and the item will reward the one that fits the described constraint. Working through a varied set of items under timed conditions is the most direct way to calibrate your readiness across this topic's breadth.

After two topics focused on language and agents, this one pivots to visual data. The domain covers both generation and understanding: producing images and video from prompts, and extracting meaning from visual inputs using multimodal models and Content Understanding pipelines. The responsible AI sub-topics here are specific to visual content and are distinct from the text-oriented safety controls in the earlier topics, so do not assume coverage from those areas carries over.

– Image and video generation and editing

Generating images from text prompts and reference media, and generating video from the same inputs, are related but separate capabilities with different configuration surfaces. Items will test which platform controls apply to each. Image-editing workflows add another layer: inpainting, mask-based edits, and prompt-driven modifications each have distinct use cases, and the exam will present scenarios where one technique is appropriate and the others are not. Video editing workflows appear as a parallel concern. The sub-topic on selecting and applying generation and editing controls provided by the platform is deliberately broad: it tests whether you know the available levers, not just that generation is possible. Candidates who have only used default settings in practice tend to miss items here because the scenario will specify a constraint that requires a non-default control.

– Multimodal understanding and visual analysis

Building solutions that analyze visual context using multimodal models is the core skill in this cluster. Configuring caption generation, both concise and detailed, for single and multiple images is a specific task with specific configuration options in Foundry. Visual question answering grounded in visual evidence is distinct from general question answering: the grounding requirement changes how the solution is structured. Accessibility-aligned alt text and extended image descriptions are a named requirement in the sub-topics, and items may test whether you know how to configure output that meets those guidelines rather than just producing any description. Azure Content Understanding in Foundry Tools appears explicitly for extracting visual characteristics, and you need to know its role relative to multimodal models. Video analysis workflows, including processing and interpreting video segments, close this cluster.

– Content Understanding pipelines and object detection

Configuring single-task and pro mode Content Understanding pipelines is a configuration-level sub-topic: items will test what each mode enables and when to choose one over the other. Object, component, and region identification within images or video is a detection task that sits at the intersection of vision models and structured output: the exam will test whether you know how to configure a solution that produces usable, structured results rather than raw model output. These sub-topics connect to the retrieval and grounding pipeline work in Topic 5, because identified objects and extracted visual characteristics often feed downstream indexing and reasoning steps.

– Responsible AI for visual content

Responsible AI in this topic is visual-specific and the exam treats it separately from the text-safety controls covered earlier. Implementing filters to classify unsafe or disallowed visual content is one concern. Detecting and mitigating indirect prompt injection through embedded text in images is a distinct attack vector that candidates often overlook: an image can carry instructions that a multimodal model will act on, and the mitigation is not the same as a standard content filter. Enforcing visual policy rules covers watermarks, prohibited symbol detection, brand usage requirements, and potentially inappropriate content flagging. Each of these has a different technical mechanism, and items will reward candidates who can match the policy requirement to the correct enforcement approach rather than applying a single general filter to all cases.

How Implement computer vision solutions is tested

Items in this topic tend to present a business or compliance requirement and ask which combination of services, pipeline modes, or configuration settings satisfies it. The most common error pattern is treating image generation, image editing, and image understanding as interchangeable, when the exam treats them as distinct capability areas with different configuration paths. Content Understanding pipeline items reward candidates who know the difference between single-task and pro mode in practical terms, not just definitional ones. The indirect prompt injection sub-topic catches candidates who have studied text-based injection but have not considered how the same risk appears in visual inputs. Responsible AI items here are specific: a general answer about content moderation will not score when the scenario describes a visual policy enforcement requirement. Reviewing your coverage across both the generation and understanding halves of this topic before the exam is worth the time.

Text analysis on this exam is broader than it sounds. The topic combines language model-driven extraction and classification with speech input and output, including translation across both modalities. If your preparation has focused on the generative and agent topics, this area can feel like a side track. It is not: the speech sub-topics in particular introduce capabilities and integration patterns that do not appear elsewhere, and skipping them is a predictable way to drop marks.

– Language model text analysis and extraction

Extracting entities, topics, summaries, and structured JSON outputs using generative prompting and Foundry Tools is the core skill here. The structured output sub-topic is worth specific attention: producing clean JSON from a generative model requires prompt design and output validation that is different from producing free-form text, and items will test that distinction. Sentiment, tone, safety issues, and sensitive content detection are grouped together in the sub-topics, but they have different configuration surfaces and different failure modes. Translation using Azure Translator in Foundry Tools or LLM-powered translation flows is a choice with tradeoffs: the exam will present scenarios where one approach is more appropriate than the other based on quality, latency, or cost constraints. Customizing language model outputs for domain tasks such as compliance summarization and domain extraction is the sub-topic most likely to appear in a scenario that describes a specific industry context.

– Speech solutions and multimodal audio

Speech-to-text and text-to-speech workflows for agentic interactions are the entry point for this cluster. The exam treats speech as an agent modality, which means items will test how speech integrates into an agent's conversation flow rather than treating it as a standalone transcription task. Custom speech models appear explicitly in the sub-topics: knowing when a custom model is required versus when the standard model suffices is the kind of decision items will test. Multimodal reasoning from audio inputs is a distinct capability: the model is reasoning over the audio content, not just transcribing it. Speech translation using language models and Foundry Tools closes the cluster and connects back to the text translation sub-topic above. The overlap is deliberate: the exam may present a scenario that involves both audio and text translation in the same workflow.

How Implement text analysis solutions is tested

Items in this topic often combine two sub-topics in a single scenario: for example, a workflow that requires both entity extraction and speech input, or a translation task that must also detect sensitive content. Candidates who have studied each sub-topic in isolation sometimes miss these combinations. The structured JSON output sub-topic is a recurring source of difficulty because it requires you to reason about prompt design and output validation together, not just one or the other. Speech items reward candidates who understand the integration pattern with agents, not just the transcription capability in isolation. Custom speech model items are specific: they test whether you know the conditions under which customization is warranted, and a general answer about speech-to-text will not score. The translation sub-topics, both text and speech, will present scenarios with constraints that point to one approach over the other, and the item rewards matching the constraint to the correct tool choice.

This topic is the data plumbing that makes RAG and agent grounding work in practice. It covers how content gets ingested, indexed, enriched, and retrieved in a form that downstream models and agents can use. Candidates who have built generative applications but have not worked closely with indexing pipelines often underestimate this area. The sub-topics here are specific enough that general knowledge of Azure AI Search will not be sufficient on its own.

– Retrieval and grounding pipelines

Ingesting and indexing content across documents, images, audio, and video is the starting point, and the variety of content types matters: each has different preprocessing requirements before it can be indexed usefully. Semantic search, hybrid search, and vector search are distinct retrieval strategies with different relevance characteristics, and the exam will present scenarios where one is clearly more appropriate than the others based on the stated grounding requirement. Enrichment using custom or built-in skills for text, images, and layout is a configuration task: knowing which skill applies to which content type determines which answer the item rewards. The RAG ingestion flow sub-topic is specific about OCR: document ingestion that involves scanned or image-based content requires OCR as part of the pipeline, and items will test whether you include it in the right place. Connecting retrieval pipelines directly to workflows and agent tools closes this cluster and links back to the agent integration work in Topic 2.

– Document content extraction and structured output

Extracting information using multimodal pipelines that combine OCR, layout analysis, and field extraction is a compound task. Items will test whether you understand how these three components interact, not just that they can be combined. Producing clean, grounded representations for agents and RAG using Content Understanding is a specific capability: the output quality here directly affects how well a downstream agent or RAG pipeline performs, and the exam will reward candidates who understand the dependency. Implementing analyzers for generating structured or markdown outputs for downstream reasoning using Content Understanding is the most configuration-specific sub-topic in this cluster. The choice between structured and markdown output is not arbitrary: it depends on what the downstream reasoning step expects, and items will present that constraint explicitly.

How Implement information extraction solutions is tested

Items in this topic are almost always scenario-based and describe a pipeline with a specific content type, a stated grounding or extraction requirement, and sometimes a performance or quality constraint. The retrieval strategy sub-topic is a common source of lost marks: candidates who default to vector search in every scenario will miss items where hybrid or semantic search is the better fit for the described requirement. OCR items reward candidates who know where in the ingestion flow OCR belongs and what happens when it is absent or misconfigured. Content Understanding items are specific to the Foundry tooling and will not be answered correctly by general knowledge of document extraction. The structured versus markdown output sub-topic is small but precise: the item will describe a downstream consumer with a specific expectation, and the answer rewards matching the output format to that expectation. Broad coverage across both clusters in this topic is more valuable than deep knowledge of one.