AI-900 Is Retired: What Changed With AI-901 Azure AI Fundamentals

AI-900 is retired. Microsoft ended the Azure AI Fundamentals exam on June 30, 2026, and the current fundamentals exam is AI-901.

That transition matters because AI-901 is not simply AI-900 with a new code. The current exam still expects candidates to recognize core AI workloads and responsible-AI principles, but it also raises the practical baseline. Microsoft’s April 15, 2026 skills outline expects foundational technical ability, familiarity with Azure resources, Python syntax, and awareness of how APIs, SDKs, and command-line tools fit into simple AI solutions.

Anyone using an old AI-900 course should therefore treat it as a foundation, not a current syllabus. The useful question is which concepts still transfer and which parts of the learning plan need to be rebuilt for AI-901.

Keep workload recognition, but make it operational

AI-900 taught candidates to recognize broad workload categories such as computer vision, natural language processing, conversational AI, and machine learning. That remains useful because good AI design still begins with the business requirement, the available input, and the required output.

The difference is that current preparation should go one step further. If the requirement is “turn recorded speech into searchable text,” identify speech recognition and then know how a simple Azure-based application would call that capability. If the requirement is “extract invoice number, supplier, date, and total from documents,” recognize information extraction and understand what structured output the downstream application needs.

This prevents a common study problem: memorizing product labels without understanding the behavior the application actually requires.

Generative and agentic AI now belong in fundamentals preparation

Modern AI fundamentals cannot stop at classic classification and prediction examples. Generative models can create and transform text, images, audio, and other content. Agentic systems can use models together with memory, retrieval, tools, and workflows to complete multi-step tasks.

You do not need architect-level depth for AI-901, but you should recognize when a direct model call is enough and when the requirement implies a larger application pattern. A chatbot that answers a question is different from an agent that can look up account data and open a service case. Once actions are introduced, identity, permissions, confirmation, logging, and failure behavior become part of the design.

The fundamentals of AI agents are worth understanding at that conceptual level: goals, tools, state, planning, feedback, and boundaries.

Responsible AI should change what you build

The familiar Microsoft responsible-AI principles remain relevant: fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. The strongest preparation does not memorize those words as a list. It applies them to scenarios.

Consider a support-triage system. Fairness asks whether some users are consistently routed differently. Reliability asks what happens when urgency is misclassified. Privacy asks what sensitive information appears in prompts or logs. Transparency asks whether staff know which fields were generated by AI. Accountability asks who reviews errors and approves changes.

Now change the system so it can automatically refund a customer. The workload may still use the same language model, but the risk profile changes. Human approval, tool permissions, transaction limits, and auditability become much more important.

Python and APIs raise the practical baseline

AI-901 is still a fundamentals exam, but Microsoft explicitly expects foundational technical skills. A candidate should be comfortable enough with Python syntax to read and adapt short examples, pass parameters, work with basic data structures, and understand how an application calls a service.

You should also understand the role of REST APIs, SDKs, and CLIs. The goal is not to become a senior software engineer. It is to know how a simple AI application is assembled: create or identify an Azure resource, authenticate, send input, receive a result, handle failure, and use the output in a wider process.

Build small exercises rather than large projects. Send text for analysis. Call a model and parse structured output. Use a multimodal example with an image. Extract fields from a document. Create a simple agent with a bounded tool. Each exercise should be small enough that you can explain every step.

Do not confuse recognition with generation or extraction

Many AI questions become easier when you describe the input-output contract precisely. Recognizing objects in an image is different from generating a new image. Converting speech to text is different from synthesizing speech. Summarizing a document is different from extracting a fixed set of fields. Answering from retrieved evidence is different from free-form generation.

This distinction matters because different quality measures and risks apply. Extraction should be judged against source accuracy. Generation may need evaluation for relevance, groundedness, safety, and style. Recognition may need precision and recall. Agentic actions need policy and authorization checks in addition to model quality.

A simple decision table—requirement, input, output, workload, primary risk—is a better study tool than a long glossary.

Use AI-900 material selectively

Old AI-900 practice questions can still be useful when they test durable concepts. A question about identifying a vision workload or understanding fairness can still expose a real gap. The mistake is assuming that strong performance on retired AI-900 material proves readiness for AI-901.

For every legacy question you keep, add a current follow-up. If the question asks which workload detects sentiment, ask how you would implement a small text-analysis application today. If it asks which principle relates to privacy, ask what data from the application should not appear in logs or prompts.

AI-901 readiness should be assessed across theory, implementation, and scenario reasoning separately instead of treating fundamentals as one undifferentiated subject.

Build one compact portfolio of AI-901 exercises

A practical study portfolio can be small. Create five or six exercises that cover different workload types and document them consistently. State the business requirement, input, output, Azure resource or capability, responsible-AI concern, and what you would verify before production use.

One exercise might turn speech into text. Another might analyze an image. Another might generate a short answer grounded in approved content. Another might extract fields from a document. Another might use an agent to call one harmless tool. The objective is not project scale; it is the ability to explain why the selected capability fits.

In practical AI-901 exercises, reproduce the behavior yourself and then change one assumption to see how the design should respond.

Before scheduling AI-901, you should be able to read a short business scenario and explain what kind of AI workload fits, what input and output are involved, what implementation approach is reasonable, and which responsible-AI concern is most important.

You should also be able to explain the limits of your answer. A model that can generate an answer does not automatically have the authority to act. A classification score is not a business rule. A generated summary is not a verified fact. An extracted field should still be validated when the consequence of error is high.

Classical machine-learning ideas still belong in a fundamentals mental model even when generative AI gets more attention. You should recognize the difference between predicting a numeric value, assigning a category, grouping similar observations, and detecting unusual behavior. The exam does not require deep mathematics, but it does expect you to match a basic machine-learning task to a business requirement and understand that model quality depends on appropriate data and evaluation.

Implementation practice should also include failure handling. Change an input type, remove a required field, use an unsupported file, or deliberately send an unauthorized request. Observe what the API or SDK returns and decide what the application should show the user. This builds the habit of treating AI as one component in a normal software system rather than as a magical endpoint.

Keep a short evidence log for each exercise: what you built, which Azure resource or capability you used, what the input and output were, which responsible-AI concern mattered most, and one failure you tested. That makes gaps obvious and gives you a much better final-review tool than a stack of copied definitions.

Make Azure resource awareness part of the same review. Know that an AI capability still needs an endpoint, authentication, usage limits, data handling, and an application that interprets the result. Even at fundamentals level, those operational details help you distinguish a conceptual answer from something that could actually be implemented.

Use a small set of mixed scenarios for final practice rather than reviewing each workload in isolation. A single case that combines text, image, speech, or an action forces you to identify boundaries between capabilities and reveals whether you can keep the responsible-AI concerns attached to the correct stage.

During final review, make sure you can explain why a simpler capability is sometimes preferable to a more flexible one. Structured extraction is better than free-form generation when downstream software needs exact fields; a direct API call may be better than an agent when there is only one deterministic operation. Fundamentals includes knowing when not to add unnecessary AI complexity.

That level of reasoning is the real step forward from AI-900. The retired exam remains useful as historical foundation, but AI-901 asks candidates to connect the concepts to simple implementation and operational judgment. Study for that standard and the transition becomes much clearer.