Microsoft AI-901: Text, Speech and Vision — Three Foundry Labs

Microsoft AI-901 expects learners to recognize AI capabilities and demonstrate how a small application uses them. That can be harder than remembering terminology. Someone may know that sentiment analysis classifies the tone of a customer message, yet not know what input a language service expects or how to inspect the returned score. They may know what speech recognition means, yet confuse it with text-to-speech. They may choose a vision model correctly, yet have no method for checking whether the response invented something that was not visible.

This article turns three related implementation objectives into manageable labs: text analysis, speech recognition and visual understanding. It complements the existing language and speech concepts, the vision capability distinctions and the current AI-901 study plan. The emphasis is not on building a complex product. It is on making one authorized request, inspecting the result and explaining why the chosen service fits the business problem.

Microsoft’s current April 15, 2026 AI-901 blueprint allocates 55–60% of the exam to implementing AI with Microsoft Foundry. It explicitly mentions building a lightweight text-analysis application, responding to spoken prompts with a deployed multimodal model, using Azure Speech, interpreting visual input and generating images. The labs below address these skills without pretending that all modalities share one endpoint, SDK or evaluation measure.

Use three separate output contracts

Before deploying anything, describe what success would look like. In the text lab, you want a sentiment label and supporting evidence for a short synthetic customer review. In the speech lab, you want an accurate transcript of a spoken phrase, or a controlled audio response when practicing synthesis. In the vision lab, you want a supported description of what is actually visible in a photograph. The outputs are different enough that no single quality test is sufficient for all three.

Choose non-sensitive source data and an authorized Azure subscription. Resource provisioning and model calls can incur costs; set a small testing budget, use a supported region and remove unneeded resources after the exercises. Authentication varies by service. A Microsoft Foundry project and a specialized Foundry Tool such as Speech or Language may use different endpoints and client libraries, even though they appear in a common developer experience. Do not reuse an arbitrary API key or endpoint from a model-chat exercise.

Lab one: classify text using a Language analysis client

Start with a synthetic customer comment: “The delivery was late, but support resolved the problem quickly.” This contains both a negative event and a positive service experience. It is more instructive than a sentence that is unambiguously cheerful. Your business requirement is to understand sentiment, not draft a personalized reply, so a dedicated text-analysis capability can be appropriate.

Create or select a supported Language resource through the current Foundry Tools experience, and obtain the endpoint and an approved authentication method. Microsoft’s Python Language quickstart documents the azure-ai-textanalytics library for sentiment analysis. In a real deployment, prefer managed identity or another centrally controlled authentication mechanism over hardcoded keys. For a small isolated quickstart, environment variables let you supply the resource settings without writing them into the script.

pip install azure-ai-textanalytics==5.2.0

The following intentionally compact Python example uses the documented client shape. It assumes you have set LANGUAGE_ENDPOINT and LANGUAGE_KEY for a resource you are authorized to access. It is illustrative source for learning, not a claim that the sample has been run in your tenant.

import os
from azure.ai.textanalytics import TextAnalyticsClient
from azure.core.credentials import AzureKeyCredential


client = TextAnalyticsClient(
    endpoint=os.environ["LANGUAGE_ENDPOINT"],
    credential=AzureKeyCredential(os.environ["LANGUAGE_KEY"]),
)
documents = [
    "The delivery was late, but support fixed the problem.",
    "The order arrived on time and worked perfectly.",
]
results = client.analyze_sentiment(documents)
for result in results:
    if not result.is_error:
        print(result.sentiment, result.confidence_scores)
    else:
        print("Analysis error:", result.error)

Read the response critically. A document may contain mixed sentiment rather than a clean positive or negative classification. The confidence distribution helps indicate how the service evaluated the text, but a high score is not an independent business truth. Test neutral statements, sarcasm and short ambiguous messages. If a manager requires a strict escalation rule, decide how the application handles mixed or low-confidence results before turning a label into an automated action.

Expand the exercise by describing how keyword extraction or entity detection would change the output. A keyword service might identify the product or delivery topic; entity detection might identify a date or organization; summarization could condense a long exchange. None is automatically a substitute for sentiment. Choose the capability from the decision the application must support, and verify the output against a few known examples.

Lab two: recognize speech and distinguish it from synthesis

Speech recognition converts audio into text. Speech synthesis generates audio from text. They often appear in the same customer-facing application, but the direction of data flow is opposite. For AI-901, make sure you can identify which part of a system listens and transcribes, which part understands or generates a response, and which part speaks the answer aloud. A deployed multimodal model can participate in spoken-prompt workflows, while Azure Speech in Foundry Tools also provides specialized recognition and synthesis capabilities.

Use a short, consented WAV file whose words you know in advance. Record a sentence that includes an easily confused number, such as “the package contains fifteen parts.” Make the recording clearly audible first, then test a noisier version. Do not use private calls or sensitive personal identifiers for this lab. Choose a Speech resource available in your region, configure the appropriate endpoint or region and ensure the application identity or key is authorized.

Microsoft’s published Speech SDK supports a Python package named azure-cognitiveservices-speech. A small Python client can read an audio file, request a single recognition result and inspect its recognized text or cancellation/no-match condition. The exact endpoint and authentication settings depend on the resource. The sample below illustrates the familiar region/key configuration for a Speech resource; check the current official quickstart if your resource uses an endpoint-based configuration.

pip install azure-cognitiveservices-speech

import os
import azure.cognitiveservices.speech as speechsdk


config = speechsdk.SpeechConfig(
    subscription=os.environ["SPEECH_KEY"],
    region=os.environ["SPEECH_REGION"],
)
audio = speechsdk.audio.AudioConfig(filename="synthetic-speech.wav")
recognizer = speechsdk.SpeechRecognizer(
    speech_config=config,
    audio_config=audio,
)
result = recognizer.recognize_once_async().get()
print(result.reason, result.text)

Interpret the result rather than assuming a non-empty string means everything was correct. If the recognized sentence says “fifty” when the source says “fifteen,” the system must not treat the text as an authoritative quantity for billing or stock movement. Record the expected transcript, the recognized text and one suspected error cause. Different accents, microphone quality and language settings can affect the outcome. For longer conversations, a different recognition mode or asynchronous transcription workflow may be more appropriate.

A second exercise can use a supported text-to-speech capability to read a benign generated response aloud. That tests synthesis rather than recognition. For a voice assistant, clearly separate the stages: capture or receive audio, recognize or interpret the spoken prompt, generate or retrieve a response, validate it, and synthesize speech if needed. The application should know when it has uncertain input and ask a clarifying question rather than confidently speaking the wrong account number.

Lab three: interpret visual input with a deployed multimodal model

Use a harmless photograph with several facts you can verify visually: perhaps a desk holding a blue notebook, a red mug and a closed laptop. The first task is visual understanding, not document extraction. Deploy or select a model in Microsoft Foundry that supports image input and verify which image formats and request limits its endpoint accepts. Microsoft’s vision-enabled model documentation supports combining a text instruction with an image in a model call; the application must supply the image using the request shape supported by the chosen model and API.

Start in the current Foundry portal to avoid introducing an SDK problem before you understand the model’s visual capability. Upload the test image, ask “Describe the objects you can actually see,” and compare the response with the source. Then ask a deliberately impossible question such as “What is written on the notebook’s inside cover?” if that cover is not visible. A dependable response should state that the information cannot be determined from the image rather than inventing a plausible title.

Once the portal result is understood, build a small client that provides an image input and a user text question to a supported multimodal deployment. Use the current image-content request format from the selected model’s official SDK documentation; do not assume that a text-only call will infer the image simply because the file exists locally. The client should validate file type, size and image readability before sending the request. A clear error for an unsupported image is better than a model invocation with malformed input.

Measure factual grounding, not eloquence. Give each image a small answer key: number of visible mugs, color of a notebook, whether a screen is open, and one deliberately unanswerable detail. Score the model on supported facts and whether it properly handles unknowns. Test a blurred or partially occluded image and observe the change in confidence and specificity. A good application can request a clearer image or human confirmation when a result would affect a consequential business decision.

Next, distinguish visual understanding from image generation. A generative visual model creates a new picture from a prompt, so its evaluation criteria include prompt adherence, quality and policy compliance rather than agreement with an existing photograph. And distinguish both from structured extraction: if a business needs exact fields from an invoice or contract image, use a suitable extraction workflow rather than an unconstrained description. The Content Understanding extraction workflow addresses those different data and validation requirements.

Compare the three labs through their failure modes

A useful exam-style question often describes what went wrong instead of naming the service. A text-analysis tool that labels a sarcastic comment as positive may need representative evaluation examples and escalation rules. A speech recognizer that mishears a number may need better audio or language configuration. A vision model that invents an unseen detail needs stronger grounding, output checks and a safer response strategy. All three can produce a technically successful API result while still failing the user’s actual need.

Explain each fault before choosing a new resource. A new model cannot fix a missing permission. Better speech synthesis does not fix an incorrectly recognized transcript. A larger image model may not recover a detail hidden behind an object. Understanding these boundaries is more important than memorizing every option in a service catalog.

Use the labs to answer implementation questions

AI-901 expects a beginning AI developer to understand how a lightweight application connects a requirement to a supported capability. The shared sequence is straightforward: identify the input and desired output, select a suitable resource or deployed model, authenticate correctly, submit a supported request, inspect the response and validate it against the original need. The three labs differ in the model or service, the request shape and the evidence needed for trust.

A practical readiness check is to explain these exercises without looking at the code. For text, identify why you used sentiment analysis rather than generation. For speech, explain why recognizing audio and producing spoken output are separate operations. For vision, explain why the model must not describe details absent from the image. Then connect the design back to responsible AI: privacy controls for recordings and photographs, accessible alternatives for audio-only experiences, and a human owner for decisions that can cause harm.

Do not turn the lesson into a race to deploy services. If a synthetic sample works, stop and review why. Clean up resources that incur charges, keep credentials out of reports, and retain only safe test results. If you can describe one failure and one validation for each modality, you have practiced the practical reasoning behind Microsoft’s current AI-901 implementation objectives while keeping the lab manageable.