Microsoft AI-901: Microsoft Foundry Architecture
Microsoft Foundry is now central to AI-901, but candidates do not need to approach it like a cloud architect designing a global production platform. The fundamentals exam is concerned with the pieces that make an AI solution work: the resource and project context, the model, the deployment or model access path, prompts, SDK interaction, agents, tools, and the data or media a workload uses.
The AI-901 exam expects candidates to identify AI concepts and then implement foundational solutions by using Microsoft Foundry. That means architecture questions are less about memorizing a portal map and more about understanding how the components relate when you move from an idea to a working application.
The broader Azure AI Fundamentals credential therefore rewards a simple mental model: a Foundry environment gives you a place to choose and deploy models, work with AI capabilities, create agents, test prompts, and connect lightweight applications to those capabilities.
AI-901 begins with identifying what kind of problem you are solving. A chatbot, document extractor, speech interface, image-analysis tool, and image-generation application may all use Foundry, but they do not need the same model or supporting service. Architecture begins with the workload, not with clicking through the portal.
This is why the exam still spends significant weight on AI concepts. If you cannot distinguish generative AI, agentic AI, text analysis, speech, computer vision, and information extraction, the Foundry environment becomes a collection of services without a clear purpose.
At a practical level, the resource is the Azure object that anchors access to Foundry capabilities. It participates in identity, networking, billing, policy, and model access. AI-901 does not require the same infrastructure depth as an associate exam, but candidates should understand that AI features are not floating independently from Azure governance.
That resource boundary becomes more important as solutions mature. The Microsoft certification portfolio separates fundamentals from role-based engineering partly because later exams expect deeper decisions about identity, networking, deployment, cost, and monitoring.
A project gives developers a working context for models, agents, evaluations, connections, and application development. For AI-901, the useful idea is that the project groups the assets used to build and test a solution. You do not need to memorize every project setting, but you should know why a project exists.
Think of the project as the development workspace and the resource as the Azure service boundary underneath it. That distinction helps when exam scenarios describe someone selecting a model, building an agent, or connecting a client application.
Foundry exposes models from Microsoft and other providers. AI-901 candidates should understand that model choice depends on capability, modality, quality, cost, and deployment availability. A text-only workload, a multimodal application, and an image-generation task may need different model families.
The important skill is matching capability to need. A candidate does not need to memorize every model name in the catalog. Model inventories change too quickly. Instead, learn to ask whether the use case needs text generation, vision input, image generation, reasoning, smaller lower-cost inference, or another capability.
In the common Foundry workflow, a selected model is made available through a deployment or supported instant-access path. A deployment associates a callable name and configuration with a model. Applications then send requests to the deployed model rather than addressing an abstract catalog entry.
At fundamentals level, the architectural idea is straightforward: catalog selection comes before inference. A model may exist in the catalog, but the application still needs a supported way to call it. Deployment configuration can affect availability, processing location, capacity, and cost.
Deployment choice is a tradeoff, not a vocabulary test: Foundry supports different deployment approaches, including serverless API patterns and managed compute for certain open-source or custom models. Within serverless deployment, Azure can offer standard, provisioned, batch, global, data-zone, or geography-oriented choices depending on the model.
AI-901 candidates do not need to become capacity planners, but they should understand the tradeoff. Pay-per-token is suited to variable consumption, provisioned capacity is designed for predictable high throughput, batch can fit asynchronous workloads, and regional or data-zone choices can matter when data-processing location is constrained.
After a model is accessible, a client application needs an endpoint and authentication. Foundry supports API-based access through SDKs and REST interfaces. AI-901 specifically expects candidates to build lightweight clients, so it is useful to understand the request path: application code authenticates, sends a prompt or input to an endpoint, the selected deployment performs inference, and the application receives the response.
This is where basic Python matters. The exam expects enough programming knowledge to understand packages, client creation, method calls, parameters, and returned results. You should be able to read a short sample and explain what resource, endpoint, model, and prompt it is using.
Prompts sit between application intent and model behavior: Prompts are part of the architecture because they carry instructions and context into the model. A system prompt can establish behavior or constraints, while a user prompt contains the immediate task. The quality of those instructions affects the quality and consistency of the output.
Prompting is not a substitute for model selection. If the model does not support the required capability, better wording will not fix the architecture. AI-901 scenarios often become easier when you separate the question into two decisions: first choose the right capability, then decide how the prompt should guide it.
An agent is more than a chat interface. It can be given instructions, connected to knowledge, and allowed to use tools so that it can perform a task over multiple steps. AI-901 expects foundational agent understanding and basic implementation, not advanced orchestration.
The agentic AI model helps explain why architecture changes when actions are involved. Once a system can call a function or retrieve business data, the designer must think about what the agent is allowed to do, which information it should use, and how a human remains in control.
Not every AI task should be handled by a general-purpose language model alone. Foundry can connect to capabilities for speech, translation, content understanding, search, and other specialized processing. AI-901 expects candidates to recognize when a workload benefits from these tools.
That distinction is especially important for information extraction. A document-processing workload may need OCR, layout analysis, and structured fields rather than a free-form answer. The concepts behind document intelligence make it easier to see why structured extraction is an architectural choice rather than just another prompt.
Text, images, audio, and video can all become inputs to modern AI systems. AI-901 asks candidates to understand how multimodal models and specialized tools support different workloads. The architecture still follows the same broad flow: identify the input, choose the right capability, provide the required context, call the service, and handle the result.
This is why learning one small client application is useful. Once you understand how a text prompt moves through the system, it is easier to reason about an image input, a speech request, or a document-analysis call.
Fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability are not separate theory topics. They affect model selection, data handling, prompt design, content filtering, human review, and what an agent is permitted to do.
The responsible AI principles should therefore be applied while drawing the architecture, not after the system is built. If a scenario contains sensitive information, high-impact decisions, unsafe outputs, or unclear accountability, the architecture needs controls that address those risks.
AI-103 shows what happens when the same architecture becomes production-grade: The AI-103 pathway builds on the same Foundry concepts but adds infrastructure design, retrieval, vector search, CI/CD, private networking, managed identity, quotas, scaling, monitoring, cost, evaluations, multi-agent orchestration, and operational controls.
That makes AI-103 a useful boundary marker while studying AI-901. If you find yourself diving deeply into capacity planning or multi-agent observability, you have moved beyond fundamentals. Understand the concept, but keep AI-901 preparation focused on the architecture necessary to identify and implement a foundational solution.
Draw five boxes: user or application, Foundry project, model deployment, optional tools or knowledge, and output. Then add Azure resource and identity boundaries around the solution. For an agent scenario, show the model calling tools or retrieving knowledge. For extraction, show the input moving through a specialized analyzer before structured output returns to the application.
This kind of diagram helps because it forces you to explain the flow rather than memorize product names. It also reveals incorrect designs, such as sending every workload directly to a general chat model or skipping the need for deployment and authentication.
Foundry architecture becomes easier when every component has a job: The point of AI-901 is not to turn a beginner into a cloud architect. It is to make sure a candidate understands enough of the architecture to select the right AI capability and assemble a small working solution. Models provide intelligence, deployments make models callable, projects organize the work, endpoints connect applications, prompts guide behavior, tools add specialized functions, and responsible AI sets boundaries around the whole system.
If you can explain those relationships in plain language and trace a request from input to output, Foundry stops feeling like a collection of disconnected portal screens. That is the level of architecture understanding that supports both the exam and the next stage of practical Azure AI development.