Microsoft Azure AI Apps and Agents Developer

Model choice sets quality, speed and cost. You compare the models and services available, create deployments, manage quotas, and set up CI/CD so that deployments are repeatable across environments.

• The model catalog and how to compare candidates
• Deployment types and regions
• Quotas, throughput and rate limits
• Estimating and controlling cost
• Deploying Foundry resources through CI/CD
• Model versions and retirement

You build A model comparison and a scripted deployment, with a cost estimate.

AI services hold sensitive prompts and data. You secure access with identities and private networking, monitor usage and failures, and apply responsible AI controls such as content filters and policies.

• Role-based access and managed identities
• Private networking and keyless access
• Monitoring usage, errors and latency
• Content filters and safety policies
• Responsible AI principles in practice
• Logging prompts without exposing private data

You build A secured Foundry project with monitoring and content filters configured.

A generative app is more than a prompt. You build chat applications with system messages, parameters and conversation state, require structured output, and make calls resilient to errors and throttling.

• Chat and response APIs, messages and roles
• System messages and prompt design
• Temperature and other generation parameters
• Structured output with JSON schema
• Streaming responses
• Handling errors, throttling and retries

You build A chat application with a designed prompt, structured output and graceful retry.

Models do not know your data. You build RAG applications that retrieve relevant content, pass it to the model with the question, and cite what was used, then test whether the answers are actually grounded.

• The RAG flow from question to answer
• Chunking and embeddings
• Querying an index and assembling the prompt
• Citations and grounded answers
• Handling questions the data cannot answer
• Evaluating groundedness

You build A RAG application over a document set, with citations and a groundedness check.

An agent decides what to do next. You build agents in Foundry that call tools, search knowledge and keep memory across turns, and learn where to constrain them so they stay useful and safe.

• Agent concepts: instructions, tools and threads
• Function tools and built-in tools
• Connecting an agent to knowledge
• Memory across turns and sessions
• Constraining tools and permissions
• Handling tool errors

You build An agent with two tools and memory across a conversation.

Some tasks suit several agents with distinct roles. You orchestrate them in code, pass state between them, and add approval steps so a person confirms actions before they take effect.

• When to use more than one agent
• Orchestrator and worker designs
• Passing state and results between agents
• Human approval for consequential actions
• Failure handling across agents

You build Two cooperating agents with an approval step before a consequential action.

A change is only an improvement if you can show it. You trace runs, build evaluation sets, score quality and safety, and use the results to tune prompts, retrieval and model choice before and after release.

• Tracing model and agent runs
• Building an evaluation dataset
• Quality and safety evaluators
• Comparing prompt, retrieval and model changes
• Production monitoring and feedback
• Fine-tuning compared with prompting and retrieval

You build An evaluation run that compares two versions of an app and decides between them.

Generative media follows its own craft. You generate and edit images and video from prompts and reference inputs, handle the limits of each model, and build the request and storage plumbing around them.

• Image generation from text prompts
• Editing images with masks and references
• Video generation and its constraints
• Prompting for style and consistency
• Storing, serving and labeling generated media
• Cost and latency of media models

You build A service that generates and edits an image and returns the result with its metadata.

Models can read what an image or video shows. You build multimodal workflows that describe, extract and answer questions about visuals, and apply filters that block unsafe visual content in both directions.

• Multimodal prompts with images
• Analyzing video content
• Extracting structured data from images
• Visual content safety filtering
• Reducing hallucination in visual answers
• Choosing a vision service or a multimodal model

You build A multimodal workflow that analyzes images, returns structured results and filters unsafe input.

Language work goes beyond chat. You extract entities and structure from text with language models, translate it, and add speech so that agents can listen and talk.

• Entity and key-phrase extraction with language models
• Classification and summarization
• Translating text and documents
• Speech to text and text to speech
• Speech in an agent conversation
• Evaluating extraction accuracy

You build A pipeline that extracts entities from text, translates it and speaks a summary.

Retrieval quality limits answer quality. You index documents, images, audio and video for search, combine keyword and vector queries, and rank results so the grounding data is relevant.

• Designing a search index and its fields
• Vector and keyword queries together
• Hybrid search and semantic ranking
• Indexing images, audio and video
• Skillsets and enrichment
• Refreshing and monitoring an index

You build A search index across mixed media, queried with hybrid search.

A lot of knowledge sits in scans, forms and PDFs. You extract text, tables and fields with OCR and Content Understanding, validate the output, and shape it into clean data for downstream use.

• OCR and layout extraction
• Content Understanding analyzers and schemas
• Tables, forms and handwriting
• Confidence scores and validation
• Handling poor-quality input
• Loading extracted data into search and storage

You build An extraction pipeline that turns scanned forms into validated structured records.

Combine the skills in one application. You choose models and services, ground the app in documents and media, add an agent with tools, then evaluate, secure and deploy it.

• Scoping an application and picking services
• Building ingestion, search and generation
• Adding an agent with tools and approvals
• Evaluating and securing the app
• Deploying and monitoring it

You build A deployed multimodal application with a grounded agent, evaluation results and monitoring.