Overview
Implement AI solutions by using Microsoft Foundry is 55-60% of AI-901, the largest share of the exam. It covers four skill groups: generative AI apps and agents, text and speech solutions, computer vision and image generation, and information extraction with Azure Content Understanding. Each one is about building something small and working: a prompt, a deployed model tested in the portal, a lightweight client that calls it with the Foundry SDK, or an app that calls a Foundry Tool.
This domain turns the concepts from Domain 1 into decisions about implementation. You need to know where things live in a Foundry project, how a client authenticates and which name it uses to call a model, when to use a multimodal model versus a dedicated Foundry Tool such as Azure Speech or Azure Language, and how Content Understanding analyzers return structured fields. Microsoft's audience profile expects basic Python knowledge, so be ready to read short code and pick the missing step.
How it's tested
Expect build scenarios: a developer wants a specific result in Foundry, and you choose the tool, the missing step, the right parameter or the change that completes the task. Microsoft expects Python knowledge and familiarity with REST APIs, SDKs and CLIs, so be ready to read short code and put portal steps in order.
-
Choose the Foundry tool
A requirement such as transcribing calls, describing an uploaded photo or pulling fields from forms points to a deployed multimodal model, Azure Speech, Azure Language, Azure Vision or Content Understanding.
-
Complete the build
A sequence or code snippet is missing one step, such as creating the deployment, authenticating to the project endpoint, or adding prior messages to the conversation.
-
Fix the behavior
An app or agent misbehaves, for example ignoring its role or failing to use a document, and you pick the change in the system prompt, tools or configuration that fixes it.
A developer's Python chat client returns an error saying the model was not found, although gpt-4.1 is clearly deployed in the project under the name support-chat. The request passes model="gpt-4.1". In Foundry, client calls reference the deployment name, so the fix is to pass support-chat. Redeploying the model or changing regions would not help, because the deployment already exists and works.
Skills 15
Official skills from the Microsoft outline, in outline order.
2.1 Create effective system and user prompts for generative AI modelsSeparating standing instructions from the per-request task.
- What it means
- The system prompt sets the model's role, rules, tone, output format and boundaries for the whole conversation, while the user prompt carries the specific request for each turn.
- What to understand
- Effective prompts are specific about the task, give context or grounding data, state the expected format, and can include examples of desired output (few-shot prompting). Asking the model to work through steps helps with multi-part problems, and prompt changes should be tested and refined iteratively.
- How it shows up
- A chatbot keeps answering off-topic questions or uses the wrong tone, and the fix is to add explicit scope and style rules to the system prompt rather than to each user message.
- Common confusion
- Candidates put persistent rules in the user prompt; behavior that must apply on every turn belongs in the system prompt.
2.2 Deploy a model and interact with it in the Foundry portalFrom model catalog to a tested deployment in the playground.
- What it means
- In a Foundry project you choose a model from the model catalog, create a deployment with a name and deployment type, then test it in the chat playground by setting instructions and parameters and sending prompts.
- What to understand
- A deployment is what makes a model callable; it has its own name, type and capacity settings. The playground lets you adjust the system prompt, temperature and other parameters, add grounding data, and view sample code with the project endpoint for use in an app.
- How it shows up
- A sequence question asks for the order: create or open a Foundry project, select a model in the catalog, deploy it, then test in the playground.
- Common confusion
- Assuming a model in the catalog can be called directly; until it is deployed in your project, there is no endpoint for your app to use.
2.3 Create a lightweight chat client application by using the Foundry SDKCalling a deployed model from Python code.
- What it means
- A lightweight client uses the Foundry SDK (the azure-ai-projects package) to connect to the project endpoint, authenticates with Microsoft Entra ID, gets an OpenAI-compatible client, and sends prompts to a deployment.
- What to understand
- Authentication typically uses DefaultAzureCredential, which picks up your Azure CLI sign-in during development. Each request names the deployment, and because model calls are stateless, the client must keep conversation context, either by resending previous messages or by referencing a previous response, for the model to follow the conversation.
- How it shows up
- A code snippet shows a chat loop that forgets earlier turns, and the fix is to append each user message and model reply to the message history sent with the next request.
- Common confusion
- Believing the model remembers the conversation by itself; without the history or a stored previous response, each call starts fresh.
2.4 Create and test a single-agent solution in the Foundry portalDefining an agent with a model, instructions and tools.
- What it means
- In Foundry Agent Service you create an agent by choosing a deployed model, writing instructions and attaching tools, then test it in the agent playground.
- What to understand
- Tools give the agent abilities beyond the model: file search over uploaded documents for grounded answers, code interpreter for calculations and data analysis, web search for current information, and function or API calls for actions. The instructions define the agent's purpose and when to use each tool.
- How it shows up
- An agent answers policy questions from general knowledge instead of the company handbook, and the fix is to attach the handbook through a file search tool and tell the agent in its instructions to answer from it.
- Common confusion
- Expecting an agent to use a document just because it was uploaded to the project; it uses knowledge only through a tool attached to that agent.
2.5 Create a lightweight client application for an agentCalling an existing agent from code.
- What it means
- A client app connects to the Foundry project with the SDK, references the existing agent, starts a conversation, sends user messages and reads the agent's responses.
- What to understand
- Unlike a plain chat client, the agent service keeps the conversation state for you, so the client sends each new message into the same conversation rather than resending the full history. The agent's model, instructions and tools are defined on the service side, so the client does not repeat them.
- How it shows up
- A question asks which object the client must create before sending the first user message, and the answer is a conversation (thread) to hold the exchange.
- Common confusion
- Redefining the agent's instructions inside the client app; the app should call the agent that was already configured and tested in the portal.
2.6 Build a lightweight application that includes text analysisCalling a text analysis capability from an app.
- What it means
- An app can analyze text either by calling Azure Language in Foundry Tools for sentiment, key phrases, entities, PII detection and summarization, or by prompting a deployed language model to perform the analysis.
- What to understand
- Azure Language returns consistent, structured results with confidence scores for each task, which suits high-volume, repeatable analysis. A language model is more flexible for custom instructions but its output depends on the prompt and needs a defined format to be parsed reliably.
- How it shows up
- A developer needs to redact names, phone numbers and email addresses from support tickets before storing them, which points to PII detection in Azure Language.
- Common confusion
- Using sentiment analysis to find what customers mention; sentiment scores opinion, while entities or key phrases identify the subjects.
2.7 Respond to spoken prompts by using a deployed multimodal modelSending audio directly to an audio-capable model.
- What it means
- An audio-capable multimodal model, such as a GPT-4o family audio model deployed in Foundry, can accept a spoken prompt as audio input and respond in text or audio without a separate speech-to-text step.
- What to understand
- The audio is sent as an input content part in the message, typically base64-encoded with its format stated, alongside any text instructions. The model must support audio input; sending audio to a text-only deployment fails, and real-time voice conversations use dedicated realtime model deployments.
- How it shows up
- A scenario wants an assistant that listens to a spoken question and answers it in one model call, which points to deploying an audio-capable multimodal model rather than chaining separate services.
- Common confusion
- Assuming every chat model can take audio; only models that list audio input as a capability can.
2.8 Build a lightweight application by using Azure Speech in Foundry ToolsSpeech to text and text to speech with the Speech SDK.
- What it means
- Azure Speech in Foundry Tools provides speech recognition, speech synthesis and speech translation through the Speech SDK and REST APIs, configured with the resource endpoint or region and a credential.
- What to understand
- A speech config identifies the resource, sets the recognition language or synthesis voice, and is used to create a speech recognizer or speech synthesizer. Audio config chooses the microphone, speaker or an audio file, and SSML gives detailed control over synthesized speech.
- How it shows up
- An app must read order confirmations aloud in a specific neural voice with a pause before the order number, which calls for a speech synthesizer with SSML.
- Common confusion
- Picking a speech recognizer to produce audio output; recognizers turn audio into text, synthesizers turn text into audio.
2.9 Interpret visual input in prompts by using a deployed multimodal modelAsking a model questions about an image.
- What it means
- A vision-capable multimodal model accepts a user message that combines text with one or more images, supplied as a URL or a base64-encoded data URL, and answers questions about what it sees.
- What to understand
- This is flexible, natural-language image understanding: describing a scene, reading a chart, comparing two photos or checking an image against instructions. The image is part of the prompt, so token costs rise with image size and detail.
- How it shows up
- A field technician uploads a photo of a damaged part and asks what is wrong, and the solution sends the photo and question together to a vision-capable deployment.
- Common confusion
- Sending only the image URL as text in the prompt; the image must be passed as an image content part so the model actually receives it.
2.10 Create new visual outputs by using generative modelsGenerating images from text prompts.
- What it means
- An image-generation model deployed in Foundry, such as a GPT-image model, creates new images from a text prompt, with options such as size and quality, and some models also support editing an existing image.
- What to understand
- Prompt detail drives the result: subject, style, composition and lighting all matter. Generated images pass through content filtering, so a request that violates content policies is blocked, and responsible AI practice includes labeling AI-generated images.
- How it shows up
- A marketing team wants product banner images in a consistent style, and you choose an image-generation deployment and a detailed descriptive prompt.
- Common confusion
- Expecting a vision-capable chat model to output images; interpreting images and generating them are different capabilities served by different models.
2.11 Build a lightweight application that includes vision capabilitiesAdding image analysis to an app with Azure Vision or a multimodal model.
- What it means
- An app adds vision by calling Azure Vision in Foundry Tools image analysis for captions, tags, objects, people and text (OCR), or by sending images to a vision-capable model deployment.
- What to understand
- Image analysis returns structured results with bounding boxes and confidence scores, which suits consistent processing at scale. Facial detection is available through the Face service, while identification and verification of people are Limited Access features that require approval.
- How it shows up
- A photo archive needs searchable tags and printed text from millions of images, which points to the image analysis features in Azure Vision rather than open-ended prompts.
- Common confusion
- Assuming the Face service can identify individuals without approval; identification and verification are restricted capabilities.
2.12 Extract information from documents and forms by using Azure Content Understanding in Foundry ToolsStructured fields from invoices, receipts, contracts and forms.
- What it means
- Content Understanding uses an analyzer to process a document and return structured JSON, including the document's text and layout as markdown plus the fields defined in the analyzer's schema.
- What to understand
- Prebuilt analyzers cover common document types such as invoices and receipts, while custom analyzers use your own field schema. For documents, fields can be extracted as they appear, generated (for example a summary) or classified into categories, and confidence scores with source grounding help decide when a human should review a value.
- How it shows up
- A finance team wants vendor name, invoice date and total from scanned invoices, with low-confidence values sent for review, which points to a Content Understanding analyzer with confidence scores.
- Common confusion
- Writing a long prompt for a chat model to read every form; Content Understanding gives schema-defined fields and confidence without custom prompt engineering.
2.13 Extract information from images by using Content UnderstandingSchema-driven fields from photos, charts and diagrams.
- What it means
- An image analyzer in Content Understanding returns the fields you define for an image, such as the type of chart, the damage visible in a photo or the brand on a label.
- What to understand
- Image fields are generated or classified from what the model sees, since the extract method is supported for documents only. Use classify when the value must come from a fixed list, and generate when the value is descriptive text.
- How it shows up
- An insurer wants each claim photo tagged with a damage category from a fixed list, which points to a classify field in an image analyzer.
- Common confusion
- Expecting the extract method on images; for images, values are generated or classified.
2.14 Extract information from audio and video by using Content UnderstandingTranscripts, summaries and fields from recordings.
- What it means
- Audio analyzers transcribe speech, separate speakers and return defined fields such as a call summary, caller intent or sentiment, while video analyzers process the visual and audio tracks into segments with descriptions, transcripts and fields.
- What to understand
- Audio and video fields are generated or classified rather than extracted verbatim. Results carry timestamps, so a value such as a product mention can be traced back to the moment it occurs in the recording.
- How it shows up
- A call center wants each recorded call to produce a summary, a resolution status from a fixed list and the customer's sentiment, which is an audio analyzer with generate and classify fields.
- Common confusion
- Assuming a transcript alone meets the requirement; the scenario usually wants specific fields derived from the transcript.
2.15 Build a lightweight application with information extraction capabilities by using Content UnderstandingCalling an analyzer from code and using the results.
- What it means
- A client app sends a file or URL to a Content Understanding analyzer through the REST API or SDK, waits for the asynchronous analysis to finish, and reads the structured fields from the result.
- What to understand
- Analysis is a long-running operation: the app submits the request, then polls the returned operation until it completes. The app then reads each field's value and confidence and decides whether to store it, route it for human review, or pass it to another system.
- How it shows up
- A code snippet submits a document and immediately tries to read fields from the first response, and the fix is to poll the operation until it reports success.
- Common confusion
- Treating the analyze call as synchronous and reading results before the operation has finished.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Foundry project
A project is the workspace inside a Foundry resource where you deploy models, create agents, connect tools and get the single endpoint that client apps call.
- Remember
- Client code connects to the project endpoint, not to an individual model in the catalog.
- Tested as
- Most build sequences start with creating or opening a project.
- Trap
- Thinking you can call a catalog model without first deploying it in a project.
-
Deployment name
Every deployed model has a deployment name chosen when it is created, and client requests use that name to route calls.
- Remember
- Pass the deployment name in the model parameter of a request, which may differ from the base model name.
- Tested as
- A favorite cause of failing code in snippet questions.
- Trap
- Using the catalog model name when the deployment has a different custom name.
-
System prompt
The system prompt holds standing instructions about role, scope, tone, format and safety that apply to every turn of a conversation.
- Remember
- Put rules that must always apply in the system prompt, and put the specific task in the user prompt.
- Tested as
- The fix for most chatbot behavior problems in scenarios.
- Trap
- Repeating behavior rules in each user message instead of setting them once.
-
Few-shot prompting
Few-shot prompting includes a small number of example inputs and desired outputs in the prompt so the model copies their pattern and format.
- Remember
- Examples steer format and style without any retraining.
- Tested as
- The answer when output format is inconsistent and must match a template.
- Trap
- Choosing fine-tuning for a formatting problem that a few examples would solve.
-
DefaultAzureCredential
DefaultAzureCredential tries a chain of Microsoft Entra ID credential sources, such as environment variables, managed identity and an Azure CLI sign-in, to authenticate an app.
- Remember
- It lets the same code work on a developer machine and in Azure without embedding keys.
- Tested as
- Appears in Foundry SDK client snippets.
- Trap
- Hard-coding an API key when the scenario asks for keyless, identity-based access.
-
Conversation history
Model calls are stateless, so a chat client must resend earlier messages or reference a stored previous response for the model to follow the conversation.
- Remember
- Agent Service keeps conversation state on the service side; a plain model client does not.
- Tested as
- Explains why a chat loop forgets the user's earlier questions.
- Trap
- Assuming the deployment remembers earlier calls.
-
Agent tools
Tools extend an agent with knowledge and actions, such as file search for documents, code interpreter for calculations, web search for current facts, and function calls for business systems.
- Remember
- An agent uses data only through a tool attached to it and described in its instructions.
- Tested as
- Agent behavior questions turn on which tool is missing.
- Trap
- Uploading a file to the project and expecting the agent to use it without file search.
-
Multimodal input
Multimodal models accept images or audio as content parts in a message along with text, so one call can interpret a photo or a spoken question.
- Remember
- The deployed model must list the input type as a capability, and images go in as URLs or base64 data URLs.
- Tested as
- Tested in the spoken prompt and visual input skills.
- Trap
- Sending media to a text-only deployment.
-
Azure Speech in Foundry Tools
Azure Speech provides speech to text, text to speech with neural voices, and speech translation through the Speech SDK and REST APIs.
- Remember
- A speech config sets resource, language and voice; a recognizer outputs text and a synthesizer outputs audio.
- Tested as
- The tool for dedicated transcription and voice output scenarios.
- Trap
- Using a recognizer when the requirement is to speak a response.
-
Azure Language in Foundry Tools
Azure Language provides prebuilt text analysis such as sentiment with opinion mining, key phrase extraction, named entity recognition, PII detection, language detection and summarization.
- Remember
- Results are structured and include confidence scores, suited to consistent analysis at volume.
- Tested as
- The default choice for standard text analysis tasks in build scenarios.
- Trap
- Choosing a custom prompt to a chat model when a prebuilt task such as PII redaction meets the need directly.
-
Content Understanding analyzer
An analyzer defines how Content Understanding processes a file: its modality, settings and the field schema of values to return.
- Remember
- Prebuilt analyzers cover common scenarios, and custom analyzers use your own schema.
- Tested as
- Central to all four information extraction skills.
- Trap
- Thinking extraction needs a trained machine learning model built from scratch.
-
Extract vs. generate vs. classify fields
Extract returns a value exactly as it appears in a document, generate produces a value such as a summary, and classify picks one value from a predefined list.
- Remember
- Extract is supported for documents only; images, audio and video use generate or classify.
- Tested as
- Decides how a field must be defined for a given modality.
- Trap
- Defining an extract field for an audio or image analyzer.
-
Confidence and grounding
Content Understanding can return a confidence score from 0 to 1 for each field and the location in the source where the value came from.
- Remember
- Use a confidence threshold to route uncertain values to human review.
- Tested as
- The answer when a workflow must automate only reliable values.
- Trap
- Assuming every returned value is accurate enough for automatic processing.
-
Asynchronous analysis
Content Understanding analysis runs as a long-running operation that the client submits and then polls until it completes.
- Remember
- Read fields only after the operation reports that it has succeeded.
- Tested as
- Appears in code questions about extraction apps.
- Trap
- Reading results from the initial submit response.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Deployed multimodal model vs. dedicated Foundry Tool
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Multimodal model (text, image, audio input) | A deployed model interprets mixed inputs in natural language | Flexible and conversational; output follows the prompt | Using it where consistent structured output with confidence scores is required |
| Azure Language or Azure Vision | Prebuilt analysis tasks with fixed output schemas | Consistent structured results and confidence scores per task | Expecting open-ended answers to arbitrary questions |
| Azure Speech | Dedicated speech recognition, synthesis and translation | Fine control of voices, languages, SSML and transcription features | Chaining it in when an audio-capable model can answer a spoken prompt in one call |
| Content Understanding | Schema-driven extraction from documents, images, audio and video | Returns named fields with confidence and grounding | Replacing it with long hand-written prompts for every form type |
Chat client vs. agent client
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Chat client (model deployment) | Code sends prompts directly to a deployed model | Client manages history and supplies all instructions | Expecting the model to remember earlier turns |
| Agent client (Agent Service) | Code sends messages to an agent already defined in Foundry | Service holds instructions, tools and conversation state | Redefining instructions in code instead of calling the configured agent |
Extract vs. generate vs. classify in Content Understanding
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Extract | Return a value as it appears in the content | Documents only, such as an invoice number | Using it on images, audio or video |
| Generate | Produce a value from the content | Free-form, such as a call summary or scene description | Using it when values must come from a fixed list |
| Classify | Choose one value from predefined categories | Constrained output, such as resolved or unresolved | Leaving categories undefined |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Base model name in the request
- What candidates pick
- Redeploy the model or switch regions when a client cannot find gpt-4.1.
- Why it looks right
- A not-found error sounds like a deployment or availability problem.
- Why it's wrong
- Requests route by deployment name; if the deployment has a custom name, the client must use it, and redeploying changes nothing.
Clue to watch for The snippet passes a base model name while the scenario states a different deployment name.
-
Stateless chat treated as stateful
- What candidates pick
- Increase max tokens or change the model so the bot remembers earlier questions.
- Why it looks right
- Memory problems feel like a capacity or model quality issue.
- Why it's wrong
- A model call only sees what the request contains, so the client must include earlier messages or a previous response reference.
Clue to watch for The bot answers each question correctly but loses track of what was said before.
-
Knowledge without a tool
- What candidates pick
- Rewrite the agent's instructions to say use the employee handbook.
- Why it looks right
- Instructions control agent behavior.
- Why it's wrong
- Instructions cannot give access to data the agent cannot reach; the handbook must be attached through a file search or knowledge tool.
Clue to watch for The agent answers from general knowledge and no knowledge tool is mentioned.
-
Chat model for repeatable redaction
- What candidates pick
- Prompt a chat model to remove personal details from every ticket.
- Why it looks right
- Language models handle text tasks flexibly.
- Why it's wrong
- PII detection in Azure Language is purpose-built, returns consistent categorized entities, and avoids sending variable prompt-driven output into a compliance process.
Clue to watch for Requirements for consistent, high-volume redaction of names, phone numbers or emails.
-
Recognizer for spoken output
- What candidates pick
- A speech recognizer to read a confirmation message aloud.
- Why it looks right
- Both are speech objects in the same SDK.
- Why it's wrong
- Recognizers convert audio to text; reading text aloud needs a speech synthesizer, with SSML for pauses or pronunciation.
Clue to watch for The output of the step is audio a user hears.
-
Synchronous extraction
- What candidates pick
- Read invoice fields from the first response of the analyze call.
- Why it looks right
- Most simple API calls return results immediately.
- Why it's wrong
- Content Understanding analysis is a long-running operation; the client must poll until it succeeds before reading fields.
Clue to watch for The code submits a file and reads results with no waiting or polling step.
-
Vision model asked to draw
- What candidates pick
- A vision-capable chat deployment to produce new banner images.
- Why it looks right
- It already works with images.
- Why it's wrong
- Interpreting images and generating them are separate capabilities; new images need an image-generation model deployment.
Clue to watch for The required output is a new image, not a description of one.
Answer framework
Use these steps to answer any Foundry build scenario on AI-901.
- Identify the input modality and the required output: text answer, spoken audio, new image, structured fields, or an action.
- Choose the implementation: a deployed model for flexible generation, an agent when tools or actions are needed, or a Foundry Tool for consistent prebuilt analysis.
- Confirm prerequisites exist: a Foundry project, a deployment with a known name, and a capable model for the modality.
- Check client mechanics: Entra ID authentication to the project endpoint, deployment name in requests, history or conversation handling, and polling for long-running analysis.
- Fix behavior at the right layer: system prompt for rules, tools for knowledge, parameters for randomness, analyzer schema for fields.
Practice question
Want more like this? The AI-901 practice test has questions for every domain.
Checklist
0 of 13
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Work through this domain hands-on, in the order Microsoft lists it, because each group reuses the setup from the one before. Start by creating a Foundry project, deploying a chat model, and spending time in the playground changing the system prompt and parameters. Then write the smallest possible Python client with the Foundry SDK and make it remember a conversation; that one exercise answers a large share of the code questions.
Next, build a single agent with a file search tool and call it from a client, noting what the service stores for you that the plain chat client did not. Then cover text and speech: try Azure Language tasks such as sentiment and PII detection, synthesize a sentence with SSML, and send a short audio clip to an audio-capable model.
The most underestimated areas are Content Understanding and the vision split between interpreting and generating images. Run a prebuilt document analyzer, then build a custom analyzer for an image or audio file so you see why extract works only for documents. Keep a table of which tool fits which requirement.
Afterwards, revisit Domain 1 to tie each build back to the workload and responsible AI concepts, then take timed practice questions that mix both domains.
FAQ
How much of AI-901 is Domain 2?
Implement AI solutions by using Microsoft Foundry is weighted at 55-60%, the largest share of the exam.
Do I need to write code for AI-901?
Microsoft's audience profile expects knowledge of Python syntax, and the study guide says to be familiar with REST APIs, SDKs and CLIs, so you should be able to read short snippets and identify a missing or wrong step. Building the small apps yourself is the most reliable preparation.
What is Microsoft Foundry?
Microsoft Foundry, formerly Azure AI Foundry, is Azure's platform for building AI apps and agents. A Foundry resource holds projects where you deploy models, create agents and use Foundry Tools such as Azure Speech, Azure Language, Azure Vision and Content Understanding.
When should I use Content Understanding instead of prompting a model?
Use Content Understanding when you need the same defined fields from many files, with confidence scores and grounding for review. Prompting a model suits one-off or open-ended questions about content.
What is the difference between a chat client and an agent client?
A chat client calls a model deployment directly and must manage history and instructions itself. An agent client calls an agent defined in Foundry Agent Service, which holds the instructions, tools and conversation state.
Does a vision-capable model also generate images?
No. Interpreting images is a capability of vision-capable multimodal models, while creating images needs an image-generation model deployment.
How long should I study this domain?
As a planning estimate, about 15 to 20 hours, most of it hands-on in a Foundry project with a small Azure budget or a free trial.
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 2 knowledge
You have covered prompting and deploying models, chat and agent clients, text, speech and vision apps, and Content Understanding extraction in Foundry. Test whether you can pick the right tool and the missing step in timed build scenarios.
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-901 AI tutor Get any concept explained your way