The implementation weighting on AI-901 makes hands-on practice necessary, but the right labs are intentionally small. Microsoft is not asking fundamentals candidates to design enterprise-grade retrieval systems, multi-agent platforms, or full MLOps pipelines. It is asking them to connect core AI concepts to lightweight Microsoft Foundry tasks.

The best lab is therefore one you can explain from beginning to end. You should know the requirement, the model or tool selected, the input, the output, the responsible-AI concern, and the small amount of application code or portal configuration that connects those pieces.

The exercises below are designed around the current objectives. Their value comes from observing cause and effect, not from producing a polished demo.

Exercise 1: compare system and user prompts on one deployed model

Deploy a suitable model in Foundry and create a simple task such as summarizing a short support transcript. Begin with a minimal user prompt. Then add a system instruction that defines role, tone, length, and output structure. Keep the source text unchanged so you can see what the system instruction contributes.

Next, deliberately place contradictory instructions in the user prompt. Observe how the model handles the conflict and think about which behavior should be considered application policy versus user intent. The exercise makes system and user prompts concrete without relying on memorized definitions.

Finish by writing down one responsible-AI consideration for the same task. If the transcript contains personal information, privacy and security immediately become relevant. A prompt can shape output, but it is not itself a privacy architecture.

Exercise 2: choose models by modality instead of popularity

Create three requirements: summarize a paragraph, interpret an image, and respond to spoken input. For each one, identify what model capability is required before looking at available deployments. The goal is to practice matching capability to need.

If a model cannot accept a required modality, it is not an appropriate choice even if it is powerful in other areas. If the task is simple text analysis, an open-ended generative workflow may be unnecessary. Write a one-sentence justification for each choice.

This lab is useful preparation for candidates coming from older AI-900 material because it shifts attention from recognizing product names toward selecting capabilities inside the current Foundry-centered exam.

Exercise 3: build the smallest possible chat client

Use the Foundry SDK to create a lightweight client that sends input to a deployed model and displays the response. Keep the interface simple. The purpose is to understand the application flow, not to build a production user experience.

Identify where the deployment configuration is referenced, what message content is sent, and what part of the returned object contains the model response. Then add one small input validation rule so that the client demonstrates that application logic and model behavior are separate layers.

If the code feels unfamiliar, review only the Python constructs needed to read it. AI-901 assumes foundational programming knowledge, not professional software-engineering depth.

Exercise 4: create and test one agent

Create a single-agent solution in the Foundry portal with a narrow purpose. Give it a clear instruction set and test several inputs that are inside and outside that purpose. Record where the agent behaves predictably and where the instructions need clarification.

Then create or inspect a lightweight client that interacts with the agent. Compare the client path with the direct chat client from the previous exercise. The most important learning outcome is recognizing what an agent changes in the solution model.

Avoid expanding into multi-agent orchestration. Candidates who later move to AI Agent Builder can explore that depth, but AI-901 only requires a basic single-agent implementation.

Exercise 5: perform one text-analysis task without turning it into chat

Choose a short set of customer comments and build a lightweight text-analysis workflow that extracts sentiment, entities, keywords, or a concise summary. Decide which output would actually be useful to a downstream process.

Compare this with asking a general generative model to “analyze the comments.” The narrower text-analysis task can produce a more predictable structure when the requirement is specific. This comparison helps distinguish workload selection from model enthusiasm.

Write down the input, the expected structure, and one failure condition. For example, ambiguous language may reduce sentiment confidence, while poor entity boundaries may affect downstream routing.

Exercise 6: handle spoken input and speech output

Use Azure Speech in Foundry Tools or a supported multimodal path to process a spoken prompt. Observe how the input changes compared with a typed request. If the exercise includes synthesis, compare the text response with the spoken output.

The learning objective is the modality chain. Speech recognition converts spoken input into information the application can work with; speech synthesis produces spoken output. A multimodal model may support a different interaction pattern. Be able to explain which capability is doing which job.

Keep the scenario practical, such as a simple voice-enabled information request. Complex contact-center architecture is unnecessary at fundamentals level.

Exercise 7: use visual input, then create visual output

Provide an image to a deployed multimodal model and ask for a focused interpretation rather than a vague description. For example, request identification of visible objects relevant to a maintenance checklist. Then test a separate image-generation task with a clearly defined visual requirement.

The two tasks look similar because both involve images, but one interprets existing visual content while the other creates new visual content. That difference is worth making explicit because the current blueprint includes both computer vision and image generation.

Consider a responsible-AI risk in each direction. Visual interpretation can misidentify important content; generated images can create misleading or inappropriate representations. Reliability and transparency are therefore part of the exercise.

Exercise 8: extract structured information from four content types

Use Content Understanding with a document or form first. Identify the fields or facts the application needs and inspect the structured result. Then repeat the reasoning for an image, an audio source, and a video source, even if you only complete one or two hands-on variants.

The point is to recognize that information extraction is not a synonym for summarization. The application needs structured information that can be used by another process. A form-processing task might need dates, amounts, identifiers, or names rather than a paragraph of prose.

If you have prior data experience, connect the exercise to DP-900 thinking: downstream systems become easier to automate when the extracted information has a defined structure and meaning.

Exercise 9: run a responsible-AI review on the same small application

Take any one of the previous labs and review it against fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. Do not try to invent a problem for every principle. Instead, identify which ones materially apply to the chosen scenario and why.

For a support assistant, transparency may require making it clear that the response is AI-generated and may have limitations. Privacy may require careful handling of customer content. Reliability may require the user to confirm critical information before acting.

This exercise turns the responsible-AI list into design judgment. It also keeps the implementation half of the exam connected to the conceptual half.

Exercise 10: combine the pieces in one mixed Foundry workflow

For the final lab, choose one realistic requirement and decide whether it needs a generative app, an agent, text analysis, speech, vision, or information extraction. Select the model or tool based on capability, create the smallest implementation, and document the responsible-AI consideration.

Do not add components that the requirement does not need. The exam is fundamentals-level, so a clear two-step solution is often more educational than a complicated architecture. The purpose is to show that you can move from problem to capability to implementation deliberately.

If your longer-term goal is AI-103, keep this lab as a baseline. The associate-level path adds much more engineering depth, but the discipline of choosing the simplest correct AI pattern remains valuable.

Exercise 11: compare two model configurations without changing the task.

Use the same prompt and input with two reasonable configuration choices, changing only one parameter or deployment choice at a time. Observe whether the output becomes more variable, more constrained, longer, shorter, or otherwise different. The purpose is not to memorize every possible setting; it is to understand that deployment and configuration are part of model behavior.

Record which differences come from the model capability and which come from the configuration. This distinction supports the blueprint objective that asks candidates to identify appropriate deployment options and configuration parameters. A model is not a fixed black box once it is placed in an application.

Keep the exercise simple enough that you can attribute the change. If you alter the prompt, model, configuration, and input simultaneously, you learn very little about cause and effect.

Exercise 12: review a lab as both a user and an implementer.

Choose one completed exercise and run it twice: once as the person using the application and once as the person responsible for building it. As a user, ask whether the interface makes the system’s purpose and limitations clear. As an implementer, ask whether the chosen workload, model, instructions, and output structure actually match the requirement.

Then test one failure case. Provide ambiguous input, an unsupported modality, incomplete information, or a request that falls outside the solution’s intended scope. Observe how the application responds and decide whether the result raises reliability, transparency, privacy, or another responsible-AI concern.

This review is valuable because the exam connects technical capability with responsible use. A lab is not complete merely because it returns output. You should be able to explain whether the output is appropriate for the scenario and what limitation the user needs to understand.