Azure AI Fundamentals (AI-901) — Complete Study Guide

Microsoft retired the long-running AI-900 exam on June 30, 2026, and replaced it with AI-901: Azure AI Fundamentals, which reached general availability in June 2026. You earn the same Azure AI Fundamentals certification — a credential that never expires — but the exam itself has changed character. Where AI-900 was almost entirely conceptual, AI-901 shifts the weight toward hands-on work in Microsoft Foundry: deploying models, writing prompts, building simple agents, and extracting information from documents, images, audio, and video with Azure Content Understanding. Microsoft now expects candidates to be comfortable reading basic Python, recognizing REST API patterns, and understanding how SDKs talk to deployed models.

Don't let "hands-on focus" intimidate you. There are no labs on the exam — you'll never type code into a live environment. You will, however, see code snippets, portal screenshots described in words, and scenario questions that assume you've actually clicked through the Foundry portal at least once. This guide covers every topic in the official skills outline (dated April 15, 2026), organized exactly around the exam's two skill areas and their weights.

How to Use This Guide

Work through Part 1 before Part 2 — the concepts in Part 1 (responsible AI, how generative models work, workload types) are the vocabulary Part 2 assumes. Then spend real time in a free Foundry project if you can: fifteen minutes in the Chat playground teaches you more than an hour of rereading.

Throughout the guide you'll see four kinds of callouts:

Aim to answer this question at the end of every section: "If the exam described this scenario, could I name the right service, model type, or portal action?" AI-901 is a matching exam at heart — scenario on one side, capability on the other.

Part 1 · Identify AI concepts and capabilities (~42%)

This domain is officially weighted at 40–45% of the exam. It tests whether you understand what AI can do, which workload type fits a scenario, and how to think about AI responsibly — before you ever touch the Foundry portal.

The Six Responsible AI Principles

Microsoft builds every Azure AI service around six responsible AI principles, and the exam will test them — usually by describing a situation and asking which principle applies. Learn each principle with a concrete example, because the questions are scenario-based, not definitional.

1. Fairness. AI systems should treat all people equitably and avoid affecting similarly situated groups differently. Example: A bank uses a model to approve loans. If the model was trained on historical data where one demographic group was unfairly rejected, it may perpetuate that bias. Fairness means testing the model's approval rates across groups and correcting skew before deployment.

2. Reliability and safety. AI systems should perform consistently, handle unexpected conditions, and fail safely. Example: An AI-assisted autonomous vehicle must respond predictably in fog or heavy rain — and if it can't, it should hand control back to the driver rather than guess. Similarly, a medical triage bot should be rigorously tested against edge cases before release.

3. Privacy and security. AI systems should protect data, both during training and in production. Example: A hospital chatbot that answers patient questions must not leak one patient's records to another, must encrypt data in transit and at rest, and should minimize the personal data it retains.

4. Inclusiveness. AI should empower everyone, including people with disabilities, and work across languages, cultures, and abilities. Example: A speech-enabled banking app should work for users with speech impairments, offer text alternatives, and support multiple languages rather than assuming one accent or one modality fits all.

5. Transparency. People should understand how an AI system works, what it can and cannot do, and when they are interacting with AI. Example: A credit-scoring system should be able to explain which factors influenced a decision, and a customer-service chatbot should disclose that it's a bot — not impersonate a human agent.

6. Accountability. People — not algorithms — are answerable for AI systems. Organizations need governance: clear ownership, review processes, and the ability to override or roll back a system. Example: A company deploying a résumé-screening model designates a team responsible for auditing its decisions and provides an appeal path for rejected candidates.

How Generative AI Models Work

Generative AI models create new content — text, images, code, audio — rather than just classifying or predicting labels. The exam expects a working mental model of how they do it.

Modern language models are built on the transformer architecture. Training works in broad strokes like this:

1. 1Tokenization. Text is broken into tokens — words or word fragments. "Unbelievable" might become "un", "believ", "able". Models read and produce tokens, not characters, which is why limits are measured in tokens.
2. 2Embeddings. Each token is converted to a vector — a long list of numbers — that captures its meaning. Words used in similar contexts end up with similar vectors ("dog" sits near "puppy", far from "spreadsheet").
3. 3Attention. The transformer's attention mechanism lets the model weigh which earlier tokens matter most when predicting the next one. In "The river bank was muddy," attention helps the model link "bank" to "river" rather than to money.
4. 4Next-token prediction. At its core, a language model repeatedly predicts the most probable next token given everything so far. Generating a paragraph is just running that prediction in a loop.

Because output is probabilistic, the same prompt can yield different answers. Sampling parameters (covered under deployment configuration below) control how adventurous that prediction loop is.

Two more terms you must recognize:

• Context windowthe maximum number of tokens (prompt + response) a model can handle at once. Exceed it and the model "forgets" earlier content.
• Hallucination / groundednessmodels can produce fluent but false statements. Grounding a model means supplying it with trusted data (for example, your own documents) so its answers are anchored in facts rather than invented.

Selecting an AI Model by Capability

Microsoft Foundry offers a model catalog with thousands of models from Microsoft, OpenAI, Meta, Mistral, Hugging Face, and others. AI-901 doesn't expect you to know individual model names in depth — it expects you to match capability requirements to model characteristics:

• Modality. Does the scenario need text only, or must the model also understand images (a multimodal or vision-capable model), process audio, or generate images? A model that only accepts text cannot describe a photo.
• Task fit. Chat completion models converse; embedding models turn text into vectors for search and similarity; image-generation models produce pictures from text prompts; speech models transcribe or synthesize audio; reasoning models trade speed for more deliberate multi-step problem solving.
• Size and cost. Large frontier models (like the GPT-4-class families) give the best quality but cost more and respond more slowly. Small language models (SLMs), such as the Phi family, are cheaper, faster, and can even run on-device — a good fit when the task is narrow and latency or cost matters.
• Context window. Summarizing a 300-page contract needs a large context window; a short FAQ bot does not.
• Openness and licensing. Open-weight models can be fine-tuned and self-hosted; proprietary models are consumed as a service.

The Foundry catalog helps you compare candidates with model cards (capabilities, limitations, training notes) and benchmarks, and you can trial a model in the playground before committing.

Model Deployment Options and Configuration Parameters

Choosing a model isn't enough — you must deploy it to get an endpoint your apps can call. Foundry offers several deployment types, and the exam expects you to know when each fits:

After deployment, you tune behavior with configuration parameters sent on each request:

• Temperaturecontrols randomness. Low values (near 0) make output focused and repeatable; high values make it more creative and varied.
• Top-p (nucleus sampling)an alternative randomness control that limits token choices to the most probable subset. Adjust temperature or top-p, not usually both.
• Max tokens / max output tokenscaps the length of the response (and helps control cost).
• Frequency penaltydiscourages the model from repeating the same tokens.
• Presence penaltyencourages the model to introduce new topics rather than staying on ones already mentioned.
• Stop sequencesstrings that force generation to halt when produced.

In Foundry you also set a rate limit (tokens per minute) when deploying, and you can enable content filters on a deployment to screen harmful prompts and responses — a practical expression of the responsible AI principles.

Common AI Workload Scenarios

AI-901 gives heavy coverage to "which workload is this?" questions. Learn these six workload types and their signature scenarios:

The critical distinction the new exam adds is generative vs. agentic. A generative workload produces content when asked. An agentic workload pursues a goal: it can decide steps, call tools (search, APIs, code), and iterate with limited human intervention. If the scenario says "automatically completes the task end-to-end" or "decides which actions to take," think agent.

Text Analysis Techniques

Text analysis (delivered in Azure primarily through the Azure AI Language service) covers several techniques the exam names explicitly:

• Key phrase extractionpulls the main talking points from text. Feed it a hotel review and it returns phrases like "friendly staff," "noisy air conditioning."
• Entity detection (named entity recognition)finds and categorizes entities: people, places, organizations, dates, quantities, URLs. "Satya Nadella spoke in Hyderabad on Monday" yields a Person, a Location, and a DateTime. Entity linking goes further, disambiguating "Mercury" the planet from "Mercury" the element by linking to a knowledge base. PII detection is a specialized form that finds and can redact personal data such as phone numbers and email addresses.
• Sentiment analysisclassifies text as positive, negative, neutral, or mixed, with confidence scores, at both sentence and document level. Opinion mining ties sentiment to specific targets ("the food was great but the service was slow").
• Summarizationcondenses long text. Extractive summarization selects the most important existing sentences; abstractive summarization writes new sentences that capture the meaning.
• Language detectionidentifies the language of input text, a common first step in multilingual pipelines.

Speech Recognition and Synthesis

Azure's speech capabilities (the Azure AI Speech service, surfaced in Foundry as a tool) come in two symmetric halves:

• Speech recognition (speech-to-text) converts audio into text. It powers transcription of meetings and call centers, real-time captioning, and voice input for apps. Features include real-time and batch transcription, speaker identification, and custom speech models tuned to domain vocabulary (medical terms, product names).
• Speech synthesis (text-to-speech) converts text into spoken audio using neural voices that sound natural. You can choose from prebuilt voices in many languages, adjust rate, pitch, and pronunciation with SSML markup, or build a custom branded voice.

Related capabilities: speech translation converts spoken language into text or speech in another language in near real time, and language identification detects which language is being spoken.

Computer Vision and Image Generation

Computer vision models interpret visual input. Capabilities to recognize:

• Image classificationassigns a label to a whole image ("this is a cat").
• Object detectionfinds multiple objects and their locations, returning bounding boxes ("two cars here, one pedestrian there"). Classification says what; detection says what and where.
• Optical character recognition (OCR)reads printed and handwritten text in images: signs, labels, scanned pages.
• Image analysis / captioninggenerates descriptions and tags for images, detects common objects and people.
• Facial detection and analysislocates faces and attributes (with strong responsible-AI guardrails; facial recognition of individuals is a restricted, limited-access capability).

Modern multimodal models (such as GPT-4o-class models) fold vision into chat: you attach an image to a prompt and ask questions about it — "What's wrong with this circuit board?" This is the capability Part 2's "interpreting visual input" objectives build on.

Image generation goes the other direction: text prompt in, image out. Models such as DALL·E-family and GPT-image-family models generate original images from descriptions, and can also edit images or produce variations. Typical parameters include image size/resolution, style, and number of images. Generated images pass through content filters, and Microsoft applies provenance measures to label AI-generated content — transparency in action.

Information Extraction Across Modalities

Information extraction turns unstructured content into structured, usable data — and AI-901 treats it as a first-class workload spanning text, images, audio, and video:

• •
  From text and documents: pull fields (invoice number, total, due date) from forms, contracts, and receipts; classify document types; extract tables.
• •
  From images: read text via OCR, identify products or defects, extract data from charts and diagrams.
• •
  From audio: transcribe calls, then extract entities, sentiment, and action items — turning an hour of speech into a structured summary record.
• •
  From video: combine frame analysis and audio transcription to extract who appeared, what was said, key moments, and on-screen text.

In the Azure ecosystem, the flagship service here is Azure Content Understanding, which ingests documents, images, audio, and video and returns structured output against a schema you define. (Part 2 covers it in depth, because the exam's implementation objectives lean on it heavily.)

Part 2 · Implement AI solutions by using Microsoft Foundry (~58%)

This is the bigger domain (officially 55–60%) and the biggest change from AI-900. Microsoft Foundry (the evolution of Azure AI Foundry) is Microsoft's unified platform for building AI solutions: a portal, SDKs, and an agent service wrapped around a model catalog and a set of Foundry Tools (Speech, Language, Vision, Content Understanding). You need to know your way around the portal's key screens and recognize what basic SDK code does.

A quick orientation: in Foundry you work inside a project, which lives under a Foundry resource. The project gives you an endpoint, authentication (Microsoft Entra ID or API keys), deployed models, agents, and connected tools. The portal's playgrounds (Chat, Agents, Speech, Images) let you test everything before writing code.

Writing Effective System and User Prompts

Every chat interaction is a list of messages, each with a role:

• •
  The system prompt (or system message) sets the model's persona, rules, and boundaries before the conversation starts. It's written by the developer, not the end user: "You are a support assistant for Contoso. Answer only questions about Contoso products. Be concise. If unsure, say so."
• •
  User prompts are the end user's actual inputs: "How do I reset my password?"
• •
  Assistant messages are the model's prior replies, kept in the conversation so the model has context.

Effective prompting techniques the exam names or implies:

• Be specific and provide context. "Summarize this contract in three bullet points for a non-lawyer" beats "summarize this."
• Assign a persona in the system prompt to control tone and scope.
• Provide examples (few-shot prompting). Showing one or two sample input/output pairs teaches the format better than describing it. Zero-shot means no examples.
• Specify output format"respond in JSON with fields name and date" — essential when an app parses the response.
• Set guardrails in the system promptwhat topics to refuse, what tone to keep, what to do when the model doesn't know.

Deploying and Testing a Model in the Foundry Portal

The portal workflow you should be able to walk through blind:

1. 1Create a project (in the Foundry portal at ai.azure.com) — this provisions the resource and endpoint.
2. 2Browse the model catalog. Filter by capability (chat, embeddings, image generation), publisher, or deployment type. Open a model card to read capabilities and pricing.
3. 3Deploy the model. Choose a deployment name (your code references this name, not the model's catalog name), a deployment type (standard, global standard, provisioned), a model version, and a tokens-per-minute rate limit. Optionally attach a content filter.
4. 4Test in the Chat playground. Pick your deployment, set the system prompt, adjust parameters (temperature, max tokens, top-p), and chat. The playground also lets you add your own data for grounded responses and can generate starter code in Python, C#, or JavaScript from your current setup.
5. 5Grab endpoint and key from the project overview when you're ready to call the deployment from code.

Building a Chat Client with the Foundry SDK

The exam expects you to read a minimal chat client and identify what each part does. The Python shape looks like this:

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

project = AIProjectClient(
    endpoint="https://my-resource.services.ai.azure.com/api/projects/my-project",
    credential=DefaultAzureCredential(),
)

chat = project.get_openai_client()

response = chat.chat.completions.create(
    model="my-gpt4o-deployment",          # deployment name
    messages=[
        {"role": "system", "content": "You are a helpful travel assistant."},
        {"role": "user", "content": "Suggest a 3-day itinerary for Kyoto."},
    ],
    temperature=0.7,
    max_tokens=800,
)

print(response.choices[0].message.content)

What to internalize from this snippet:

• •
  The project client connects to your Foundry project using its endpoint and a credential (DefaultAzureCredential uses your Entra ID sign-in — keyless authentication, which Microsoft recommends over API keys).
• •
  From the project you obtain a chat client, then call chat completions against your deployment name.
• •
  The messages list carries the roles you learned above; multi-turn chat means appending each user message and assistant reply to the list so the model keeps context.
• •
  Parameters like temperature and max_tokens ride along on each request.

Building and Testing a Single Agent in the Foundry Portal

An agent is a language model given three extra things: instructions (a persistent system-prompt-like definition of its job), tools (capabilities it can invoke — file search over uploaded documents, code interpreter for calculations, custom actions via APIs), and state (conversation threads it can continue).

In the Foundry portal, the Foundry Agent Service lets you build one without code:

1. 1.
   Open the Agents area of your project and create a new agent.
2. 2.
   Choose the model deployment it will use.
3. 3.
   Write its instructions: role, task, constraints ("You are an HR assistant; answer using only the uploaded policy documents; escalate anything about payroll").
4. 4.
   Add tools/knowledge — upload files for retrieval, enable code interpreter, or connect actions.
5. 5.
   Test in the agent playground: chat with the agent, watch which tools it invokes, and refine the instructions.

The mental model the exam wants: the model provides raw intelligence; the instructions aim it; the tools let it act; the thread remembers the conversation.

Building an Agent Client App

Everything the agent playground does is available through the SDK. A minimal Python client app follows this shape:

agent = project.agents.create_agent(
    model="my-gpt4o-deployment",
    name="hr-assistant",
    instructions="You answer HR policy questions using the provided documents.",
)

thread = project.agents.threads.create()

project.agents.messages.create(
    thread_id=thread.id, role="user",
    content="How many vacation days do new employees get?",
)

run = project.agents.runs.create_and_process(
    thread_id=thread.id, agent_id=agent.id,
)
# then list the thread's messages to read the agent's reply

The four nouns to recognize: agent (definition: model + instructions + tools), thread (a conversation with stored history), message (one turn added to a thread), and run (asking the agent to process the thread and respond, invoking tools as needed). A client app creates or reuses an agent, opens a thread per conversation, adds user messages, starts runs, and reads back the new assistant messages.

Building a Text Analysis App

Foundry surfaces Azure AI Language as a Foundry Tool, and the portal's Language playground lets you try each capability on sample text before coding. A text analysis app typically:

1. 1.
   Connects to the Language endpoint (or via the Foundry project) with a key or Entra credential.
2. 2.
   Sends text to the operation it needs: sentiment analysis, key phrase extraction, entity recognition, PII detection, language detection, or summarization.
3. 3.
   Receives structured JSON — labels, confidence scores, extracted phrases, redacted text — and acts on it.

For example, a review-triage app might run language detection first, then sentiment analysis, and route documents with negative sentiment and high confidence to a support queue, attaching the key phrases so the human sees the gist instantly. Note that you can also perform light text analysis by simply prompting a generative model ("Classify this review's sentiment"), and the exam may ask you to weigh that: the dedicated Language service gives consistent, structured, per-capability output with confidence scores at lower cost, while a general model is more flexible but less predictable.

Confidence scores matter in app design. A production pipeline usually sets a threshold — for example, auto-route only when confidence exceeds 0.8, otherwise send to a human. That pattern is reliability and safety, applied.

Responding to Spoken Prompts — Multimodal Speech Interactions

Two implementation paths let apps hold spoken conversations, and the exam expects you to know both:

Path 1 — Azure Speech via Foundry Tools (the classic pipeline). Chain three steps: speech-to-text transcribes the user's audio; the text goes to your chat model or agent; text-to-speech speaks the reply with a neural voice. Each stage is independently configurable (language, voice, custom vocabulary), which makes this path predictable and widely supported. The Speech playground in Foundry lets you test transcription and voices interactively.

Path 2 — a speech-capable multimodal model. Newer realtime/multimodal models accept audio input directly and can produce audio output, skipping the explicit transcription step. The model "hears" tone and pacing and responds with lower latency and more natural turn-taking — the design behind realtime voice assistants.

Choose the pipeline when you need fine control (specific voices, custom vocabulary, saved transcripts, broad language coverage); choose the multimodal path when natural, low-latency conversation is the priority.

Interpreting Visual Input in Prompts — Vision-Capable Apps

With a vision-capable (multimodal) model deployed — GPT-4o-class models are the canonical example — your prompts can include images alongside text. In the Chat playground you attach an image and ask about it; in code, the user message carries both a text part and an image part (a URL or base64-encoded data):

messages=[
    {"role": "user", "content": [
        {"type": "text", "text": "What safety issues do you see in this photo?"},
        {"type": "image_url", "image_url": {"url": "https://.../site-photo.jpg"}},
    ]}
]

Vision-capable app scenarios the exam favors: describing or captioning photos for accessibility, checking product images against listing text, reading a whiteboard photo into meeting notes, or answering questions about charts and screenshots. The build recipe is always the same: deploy a multimodal model, send mixed text-plus-image messages, handle the text response.

Generating Visual Outputs

To generate images, you deploy an image-generation model (DALL·E-family or GPT-image-family) from the catalog — a separate deployment from your chat model — and test it in the Images playground. Your app then sends a text prompt and receives an image (as a URL or base64 data), with parameters for size, quality, style, and the number of images to generate.

Prompt quality matters as much as with text: specific prompts ("a watercolor illustration of a lighthouse at dawn, soft pastel palette") outperform vague ones ("a nice lighthouse picture"). Generated content passes through content filters that block harmful requests, and outputs carry provenance signals identifying them as AI-generated — the transparency principle again. Some multimodal models can also generate or edit images inside a chat, but the dedicated image deployment remains the standard exam answer for "the app must create images from text descriptions."

Azure Content Understanding — Documents, Images, Audio, and Video

Azure Content Understanding is Foundry's multimodal information-extraction service and one of AI-901's headline additions. It ingests content in four modalities and returns structured output defined by a schema you specify — you tell it what fields you want, and it finds them.

The core workflow:

1. 1Create or pick an analyzer. Start from a prebuilt template (invoice, receipt, call-center audio, video summarization) or define a custom one.
2. 2Define the field schema. Name each field, its type, and a description — e.g., vendor_name (string), invoice_total (number), line_items (array). Descriptions act like prompts guiding the extraction.
3. 3Test with sample content in the Foundry portal, review the extracted values and confidence scores, and refine the schema.
4. 4Call the analyzer from your app via REST or SDK; it returns JSON matching your schema.

What it does per modality:

The unifying idea: one service, one schema-driven pattern, four modalities. That's what distinguishes it from calling separate vision, speech, and language services and stitching results together yourself.

Building an Information-Extraction App

The capstone objective ties the pieces together. A typical information-extraction app:

1. 1Receives contentfiles land in Azure Blob Storage, arrive via upload, or stream from a call platform.
2. 2Sends each item to a Content Understanding analyzer (prebuilt or custom) through the REST API or SDK. Analysis is asynchronous for large files: submit, then poll for or receive the result.
3. 3Validates the structured result. Check confidence scores; auto-accept high-confidence fields, queue low-confidence ones for human review — the human-in-the-loop pattern that operationalizes accountability.
4. 4Stores and acts on the datawrite fields to a database, trigger workflows, feed dashboards, or hand the structured facts to an agent for the next step (e.g., an agent that reads the extracted claim data and drafts a response).

Design considerations the exam may probe: choose prebuilt analyzers when your documents match common types (invoices, receipts) and custom schemas when they don't; expect per-page or per-minute pricing to shape batch design; and keep personal data handling aligned with privacy and security — redact PII you don't need.

Exam-Day Checklist

• •
  Do the math on pace: ~50 questions in 45 minutes is under a minute each. Fundamentals questions are short — read the scenario's deciding constraint and answer; flag anything that takes longer than 90 seconds and return to it.
• •
  Know the six responsible AI principles cold, each with an example, and practice telling apart the near-miss pairs (transparency vs. accountability, fairness vs. inclusiveness).
• •
  Rehearse the workload match-ups: generative vs. agentic, classification vs. object detection, text analysis techniques by verb, information extraction whenever structured fields come out.
• •
  Walk the Foundry portal once more: create project → browse catalog → deploy (deployment name!) → playground → endpoint and key. Same for the agent flow: agent → instructions → tools → thread → run.
• •
  Re-read the two Python shapes (chat client and agent client) until you can label every line's purpose. The exam shows code to read, not write.
• •
  Remember parameter effects: temperature/top-p = randomness, max tokens = length, frequency/presence penalties = repetition and topic novelty, system prompt = persistent behavior.
• •
  Drag-and-drop and build-list questions reward knowing sequences — deployment steps, the speech pipeline (speech-to-text → model → text-to-speech), and the Content Understanding workflow (analyzer → schema → test → call).
• •
  Arrive early (or test your online-proctoring setup the day before), and remember there's no penalty for guessing — answer everything.

Official Resources

• AI-901 exam pagethe official registration page, current skills outline, and scheduling options: learn.microsoft.com/credentials/certifications/exams/ai-901
• Official AI-901 study guideMicrosoft's skills-measured breakdown with change log (check it shortly before your exam date for updates): learn.microsoft.com/credentials/certifications/resources/study-guides/ai-901
• Course AI-901T00: Microsoft Azure AI Fundamentalsthe instructor-led course aligned to the exam; the equivalent self-paced learning paths are free on Microsoft Learn: learn.microsoft.com/training/courses/ai-901t00
• Microsoft Foundry documentationportal walkthroughs, SDK quickstarts, agent service, and Content Understanding docs: learn.microsoft.com/azure/ai-foundry
• Microsoft Learn practice assessmentfree practice questions in the exam's style, linked from the exam page once available for AI-901.

Study the concepts, click through Foundry with your own free project, take a practice assessment, and you'll walk into AI-901 ready. Good luck — and enjoy the fact that this credential, once earned, never expires.