Microsoft Azure AI Explained: OpenAI Service, Foundry, and AI Infrastructure in One Guide

Human Verified

Share to: , and

A wide, calm illustration of a vast cloud platform as a city of glowing data-centre buildings under a blue sky, one unified platform. No text, no logos.

Microsoft Azure AI Explained: OpenAI Service, Foundry, and AI Infrastructure in One Guide

Azure AI is Microsoft’s answer to a simple question: where do you actually run AI when you are a business? The answer is a platform, not a single product — a catalogue of more than 10,000 models, a managed service for building agents, and a set of specialist tools for speech, vision and documents, all billed to one Azure subscription and governed by one set of enterprise controls. As of 19 November 2026 the platform is called Microsoft Foundry, and this guide maps it in full: what each part does, how Azure OpenAI differs from buying straight from OpenAI, what the models cost, and what the enterprise controls actually buy you. Checked 19 November 2026 against Microsoft’s own documentation, read in full.

Two things confuse almost everyone who meets Azure AI for the first time, and this guide clears both up before anything else. The first is the name. In three years the platform has had three names — Azure AI Studio, then Azure AI Foundry, then Microsoft Foundry — and tutorials, documentation and blog posts use all three, often in the same week. They are the same platform at different ages, and the section on the name problem untangles them. The second confusion is what you are actually buying. Azure AI is not a chatbot, and it is not a model. It is the place where models live and where applications built on them run, and the models themselves come from OpenAI, Anthropic, Meta, Mistral, DeepSeek, Moonshot and Microsoft itself. Picking the platform and picking the model are two different decisions, and this guide treats them as two different decisions.

There is also a correction that belongs at the top, because most explainers written even a few weeks ago get it wrong. The newest models on Azure are the GPT-6.2 family — GPT-6.2 Astra and GPT-6.2 Sol, which arrived on 17 November 2026, two days before this guide was checked. The GPT-5 family, which dominated Azure guides all year, is no longer the headline. And the old o-series reasoning models — o1, o3, o3-mini and o4-mini — retire on 19 November 2026, the day this guide is published. Any guide still recommending o3 as the reasoning choice is out of date. Prices in this guide are date-stamped “checked 19 November 2026”, because Microsoft can change them, and the Azure pricing page is the authority if the figures here have moved.

A wide, calm illustration of a vast cloud platform as a city of glowing data-centre buildings under a blue sky, one unified platform. No text, no logos.

What Azure AI Actually Is — One Platform, Three Layers

<img src="

Three stacked layers as a landscape illustration, models at the base, agents in the middle and tools on top, one platform. No text.

” alt=”Three stacked layers as a landscape illustration, models at the base, agents in the middle and tools on top, one platform. No text.”>

Azure AI is best understood as three layers stacked on top of each other, and every service Microsoft sells in this space sits in exactly one of them. The bottom layer is models: the catalogue. The middle layer is agents: the managed runtime that turns a model into something that does multi-step work. The top layer is tools: the specialist services for speech, vision, documents and safety that an agent or an application calls on. All three layers sit on one Azure resource — a Foundry resource — with one set of access controls, one network boundary and one bill. That single-resource idea is the whole point of the platform, and it is what separates Foundry from the older arrangement, where each service was a separate Azure resource with its own keys, its own network settings and its own bill.

The bottom layer, Foundry Models, is the catalogue. Microsoft’s own documentation puts it at more than 10,000 models from Microsoft, OpenAI, Anthropic, Meta and others, and the number grows by roughly 50 new models a month. The catalogue is split in two, and the split matters for contracts: models “sold by Azure” are hosted and sold by Microsoft under the Microsoft Product Terms, which covers Azure OpenAI’s GPT models plus models from Meta, Mistral, DeepSeek, Cohere, xAI and Microsoft’s own MAI family, among others. Models “from partners and community” are billed through the Azure Marketplace on the provider’s own terms — Anthropic’s Claude models sit in this group, which is why Claude’s support and service levels on Foundry are Anthropic’s, not Microsoft’s. The same split decides who processes your data: for models sold by Azure, Microsoft hosts and operates the model; for partner models, the partner runs the inference, even when the bill comes through Azure.

The middle layer, Foundry Agent Service, is where a model becomes an agent. An agent is a model paired with instructions and tools that can reason over a request and take action — read a file, search the web, call your company’s systems, remember what happened earlier in the conversation. Microsoft offers three ways to build one, from the least to the most control: a prompt agent, declared in the portal or the SDK with no application code; a voice-based prompt agent, for real-time spoken experiences; and a hosted agent, where you bring your own code or framework — Microsoft Agent Framework, LangGraph or Semantic Kernel — packaged as a container, and Foundry runs it with a managed endpoint, scaling, identity and observability. You can start declarative and move to code as the project grows, and most real projects do exactly that.

The top layer, Foundry Tools, is the set of specialist services that used to be called Azure AI Services: Speech, Vision, Language, Document Intelligence, Content Safety and Translator, plus Azure AI Search as the retrieval layer that lets agents look up facts in your own data. These are the services that do one job well rather than reasoning generally. A document-understanding pipeline, for example, is Document Intelligence extracting the text, a language model reading it, and Content Safety checking the output — three layers working together, which is the normal shape of a production AI application on Azure.

What ties the layers together is the Foundry resource. It is a single Azure resource of type Microsoft.CognitiveServices/accounts with kind AIServices, living in your subscription and resource group, and it contains projects. Each project is a workspace where a team builds, with its own models, agents and data connections, but the access control, networking and policies are set once at the resource level. That is the practical meaning of “one management plane”: one place to say who can use which model, which networks can reach it, and which policies apply, instead of repeating those decisions for every service.

The Name Problem: Azure AI Studio, Azure AI Foundry, Microsoft Foundry

Three signposts on a road, each pointing a different way, an old name, a newer name and a current name, the renaming idea. No readable words on the signs.

Nothing about Azure AI confuses newcomers more than the names, and the confusion is Microsoft’s own doing. The platform has been renamed twice in two years, and every rename left the old name alive in documentation, tutorials, SDKs and blog posts. The current name, as of Microsoft’s own Learn documentation, is Microsoft Foundry. The name before it was Azure AI Foundry, and the name before that was Azure AI Studio. When you see any of the three, you are looking at the same platform at a different point in its history — but the details underneath changed with each rename, so the names are not interchangeable.

The rename happened at Microsoft Ignite on 18 November 2025, when Azure AI Foundry became Microsoft Foundry and Azure AI Services became Foundry Tools. The portal moved with it: the old Foundry (classic) portal still exists for hub-based projects, but Microsoft says new investment is focused on Foundry projects in the new portal, at ai.azure.com. The API changed too. The old Assistants API (Agents v0.5/v1) gave way to the Responses API (Agents v2), with stable v1 routes under /openai/v1/ replacing the old monthly api-version parameters. And the resource model changed: the old world of a hub plus a separate Azure OpenAI resource plus separate AI Services resources collapsed into a single Foundry resource with projects inside it. If you follow a tutorial written before late 2025, expect every one of these details to look different, and check the current Learn pages before trusting it.

The renames did not stop at the platform. In August 2026 Microsoft renamed the Microsoft 365 Copilot app to Microsoft Copilot, and its Learn pages now say that Microsoft 365 Copilot is now named Microsoft Copilot and Microsoft 365 Copilot Chat is now named Microsoft Copilot Chat. The two Copilot experiences — the free consumer app and the paid work add-on — now live in one unified Microsoft Copilot app at copilot.cloud.microsoft, with an account switcher between personal and work accounts. The licence names and the pricing pages still carry “Microsoft 365 Copilot”, so you will see both forms for a while. This matters for Azure AI because Copilot is the best-known thing built on top of it, and the naming mess around Copilot is often mistaken for a naming mess inside Azure AI itself. They are separate messes. Copilot is covered in depth in our guide to Microsoft Copilot in 365; this guide treats Copilot only as a downstream consumer of the platform, not as part of it.

The practical rule is simple. When you read “Azure AI Foundry” in anything published before November 2025, translate it to “Microsoft Foundry” and check the current docs for the detail. When you read “Azure AI Studio”, you are reading about the 2024-era product, and the walkthrough will not match the current portal. And when you read “Microsoft Foundry” in anything from late 2025 onward, you are reading about the current platform. The names matter because they decide which documentation, which SDK and which portal you should be using — and because a search for “Azure AI Foundry pricing” will still return pages that describe a product Microsoft no longer sells under that name.

The Service Map: Everything Inside Microsoft Foundry

A map table with a large illustrated service map, regions and routes connecting, a platform map. No text.

Here is the whole platform on one page. If you understand this table, you understand Azure AI, and every later section is detail on one row of it.

ServiceWhat it doesWho it is for
Foundry ModelsThe catalogue: 10,000+ models, deployed behind endpoints, called by APIAnyone who needs a model — chat, reasoning, image, audio, embeddings
Azure OpenAI ServiceOpenAI’s models (GPT-6, GPT-5, Whisper, embeddings) hosted and operated by Microsoft inside AzureTeams that want OpenAI models with enterprise controls
Foundry Agent ServiceManaged runtime for agents: prompt agents, voice agents, hosted agents, with tools, memory and retrievalTeams building assistants and automations that do multi-step work
Foundry ToolsSpecialist services: Speech, Vision, Language, Document Intelligence, Content Safety, TranslatorApplications that need one capability done well
Azure AI SearchRetrieval over your own data — the RAG layer that grounds agents in company documentsAny agent or application that must answer from your data, not the model’s memory
Azure Machine LearningCustom model training, fine-tuning at scale, and MLOps for teams that train their own modelsData-science teams building or customising models
Evaluations & observabilityBuilt-in evaluators for quality, retrieval, safety and agent behaviour; tracing on OpenTelemetry into Application InsightsTeams that must prove an agent works before shipping it
Control planeEntra identity, RBAC, content filters, network isolation, Azure Policy — set once at the resource levelAdministrators and security teams

Two rows in that table deserve a warning, because they are the ones people most often misunderstand. The first is Azure Machine Learning. It still exists as a separate service, and it is the place for teams that train their own models or fine-tune at scale with full MLOps — experiment tracking, pipelines, model registries. Foundry is the place for teams that use models, including fine-tuning a hosted model on their own data. The boundary is not a wall: you can fine-tune a model in Foundry, and you can deploy a model trained in Azure Machine Learning through Foundry. But if your job is “train a model from scratch”, you are in Azure Machine Learning territory, and if your job is “call a model and build an application on it”, you are in Foundry territory.

The second is Azure AI Search, which is easy to overlook and hard to overstate. A model on its own can only answer from what it was trained on, which is frozen in time and knows nothing about your company. Azure AI Search is the service that lets an agent look things up — in your documents, your tickets, your product catalogue — and then answer from what it found. That pattern, retrieval-augmented generation, is the single most common architecture in production Azure AI applications, and it is why Search sits in the middle of the platform rather than at the edge. Microsoft claims the search service powers 2 billion daily enterprise search queries, a vendor figure reported by secondary sources; the number is less important than the role. If your agent’s answers must be grounded in your data, Search is where that grounding happens.

One more boundary is worth stating plainly. Microsoft Foundry is a platform for building AI applications. It is not a chatbot, and it is not a finished product you buy and switch on. The finished products — Microsoft Copilot, GitHub Copilot, the Copilot app — are built on top of it, and they are sold and licensed separately. Confusing the platform with the products is the most common category error in this space, and it is the reason some buyers arrive at Foundry expecting a chatbot and leave disappointed. Foundry gives you the parts and the workshop. The chatbot is something you build in it, or buy separately.

Azure OpenAI Service: OpenAI’s Models on Microsoft’s Cloud

A row of model cards as glowing abstract orbs of different sizes on a shelf, the model family. No text.

Azure OpenAI Service is the reason most organisations come to Azure AI at all. It is OpenAI’s models — the GPT family, plus Whisper for speech-to-text, text-embedding models, and image and audio models — hosted and operated by Microsoft inside Azure, under a Microsoft enterprise agreement, with Microsoft’s data handling and compliance commitments attached. The models are the same ones OpenAI sells directly. The deal around them is different, and that deal is the product.

The current model line-up, as listed on Microsoft Learn on 19 November 2026, is the GPT-6 family at the top, then GPT-5.6, GPT-5.5 and the GPT-5.1 family below it. The newest models are GPT-6.2 Astra and GPT-6.2 Sol, both version 2026-11-17, which arrived two days before this guide was checked. Below them sit GPT-6.1 Terra and GPT-6.1 Sol (September–October 2026), GPT-6 Luna, GPT-6 Sol and GPT-6 Astra (September 2026), then GPT-5.6 Sol, GPT-5.6 Terra and GPT-5.6 Luna (July 2026), GPT-5.5 (April 2026), and the GPT-5.1 family including GPT-5.1, GPT-5.1-chat, GPT-5.1-codex, GPT-5.1-codex-mini and GPT-5.1-codex-max (November–December 2025). Each family comes in variants — Sol, Terra, Luna, Astra are the codenames for the tiers inside a generation — and each model comes in short-context and long-context versions, with global, data-zone and regional deployment types that change the price. The naming is dense, and the pricing page lists every combination, which is why the price section below gives you the structure rather than a price list.

GPT-6 Astra is the current frontier, and Microsoft’s own description of it on the pricing page is worth quoting because it tells you what the model is for: it is “built to decide for [an] organization, it reasons before it acts, commits to a course of action, and executes across the applications customers already run”, with computer use as “the marquee capability of this release”. That is an agentic model, not a chatbot model — a model designed to take actions in software, not just to produce text. GPT-6.1 Sol, the tier below, is the workhorse: the model most production applications will actually use, and the one whose price this guide quotes as an anchor in the pricing section. GPT-5.6 Sol and Terra are the replacements for the retiring o-series reasoning models, and GPT-5.1-codex is the coding specialist of the family.

Two things about the line-up matter more than any single model. The first is how fast it moves. The o-series — o1, o1-pro, o3, o3-deep-research, o3-pro, o3-mini and o4-mini — retires on 19 November 2026, the day this guide is published, with GPT-5.6 Sol listed as the replacement for o1 and o3 and GPT-5.6 Terra for o3-mini and o4-mini. The retirement dates are not extendable, according to Microsoft’s retirement schedule as reported by secondary sources, so any reasoning workload still built on the o-series needs a tested migration now, not next quarter. The second is that GPT-5 itself no longer appears as a headline family on the pricing page — it sits below GPT-5.1 in the list, a legacy tier. If your organisation’s Azure OpenAI deployment still defaults to GPT-5 or o3, it is running on yesterday’s models, and the model-choice section at the end of this guide tells you how to think about upgrading.

Beyond the GPT family, Azure OpenAI includes the supporting models that make a complete application possible: Whisper for transcription, text-embedding models for search and retrieval, and image and audio generation models. These are easy to forget and expensive to forget — an application that chats in GPT-6 but transcribes with a third-party service has split its data handling across two vendors, which is exactly the problem Azure OpenAI exists to avoid. The full list is on the pricing page, and the rule is simple: if a model is in the Azure OpenAI list, it runs under Microsoft’s data handling; if it is not, it does not.

Azure OpenAI vs the OpenAI API: The Same Models, a Different Deal

Two doors side by side, one plain and one with a lock and shield, same model behind both, the two routes to the same models. No text.

The most common question about Azure OpenAI is also the simplest: why pay Microsoft for OpenAI’s models when you can buy them from OpenAI? The models are the same, the API is nearly the same, and the prices are close. The answer is everything around the model — data handling, contracts, regions, access control and compliance — and for the organisations Azure OpenAI is built for, that everything is the product.

The data rule is the decisive one, and Microsoft states it unusually plainly. Your prompts, completions, embeddings and training data are not available to other customers, are not available to OpenAI or other model providers, and are not used to train, retrain or improve foundation models without your permission or instruction. The models are stateless: nothing you send is stored inside the model. The service is fully operated by Microsoft inside Azure, and it does not interact with services OpenAI runs, such as ChatGPT or the OpenAI API. Your fine-tuned models are available exclusively to you. For a company whose data is its business — a law firm, a bank, a hospital, a government department — that paragraph is the whole buying decision, and it is the reason Azure OpenAI exists.

There is a caveat, and an honest guide states it. Microsoft stores and processes data to provide the service and to watch for uses that break the product terms. If abuse indicators are detected, a sample of prompts and completions may be selected for review — first by automated means, then by authorised Microsoft staff where needed — and the flagged data is held in a store kept separate per customer. Managed customers can apply to modify abuse monitoring, including a modified-abuse-monitoring arrangement under which prompts and completions are not stored for abuse monitoring or reviewed by humans, though real-time automated safety checks may still occur. That is not the same as zero data retention by default, and anyone who needs true zero retention should apply for the exemption rather than assume it. Stateful features — Responses API message history, files, vector stores, batch processing, fine-tuning — also retain data by design, in your own Azure tenant, which you can delete at any time.

The rest of the deal follows from the data rule. Access is through Microsoft Entra identity and Azure role-based access control, so the same people who can read a database can be given — or denied — access to a model, and the same conditional-access policies apply. You choose where your prompts are processed: global deployment, data-zone deployment (EU or US) or regional deployment in one of up to 27 regions, which is the answer for data-residency requirements. Billing runs through your Azure agreement, with the same invoicing, the same support contract and the same compliance certifications — including BAA coverage for HIPAA workloads, as reported by enterprise guides. And content filtering is applied by default, with configurable thresholds, so outputs are checked against harm categories before they reach a user.

When should you pick the direct OpenAI API instead? When you are an individual developer or a small team, when you want the newest model the day OpenAI releases it rather than when it lands on Azure, when you want the widest feature set (some OpenAI features arrive on the direct API first), or when you do not have an Azure agreement and do not want one. Our guide to the OpenAI API covers the direct route in full, and our guide to OpenAI the company covers the organisation behind both routes. The rule of thumb: if your data can leave your company, the direct API is simpler and often faster to the newest features. If your data cannot leave your company, Azure OpenAI is the only one of the two that makes sense, and the price difference — where there is one — is the cost of the controls.

The Model Catalogue Beyond OpenAI: Claude, Llama, DeepSeek, Kimi and the Open Models

A marketplace of many stalls, each with a different coloured abstract banner, many model vendors in one catalogue. No legible logos.

OpenAI is the headline on Azure, but it is no longer the whole catalogue, and the breadth of the catalogue is the second reason organisations choose Foundry. The same Azure contract that buys GPT-6 also buys Claude from Anthropic, Llama from Meta, Mistral, DeepSeek, Qwen, Kimi from Moonshot, xAI’s Grok, Cohere — and Microsoft’s own MAI models, covered in the next section. You choose a model per agent or per model call, and you can swap models without changing the platform, the access controls or the billing relationship. That swap-ability is the point: the catalogue is a hedge against any single model vendor.

Claude is the most important non-OpenAI entry, and it arrived later than most people realise. Claude became generally available in Microsoft Foundry at the end of June 2026, and it comes with a choice that does not exist for OpenAI’s models. You can run it “hosted on Azure”, where inference runs on Azure, data is stored at rest in the Azure geography you pick, and a US data zone is supported — or “hosted on Anthropic”, which gets you API features the Azure-hosted version does not have yet, but where your data may be processed outside Azure. Either way Anthropic operates the models and is the data processor, which is a different arrangement from Bedrock or Google’s platform, where the cloud provider runs the inference. Claude on Foundry is also billed differently: it is a partner model, sold through the Azure Marketplace on Anthropic’s standard per-token rates, with Anthropic’s support rather than Microsoft’s SLA. The current line-up includes Claude Opus 5.5, Sonnet 5.5 and Haiku 5.5, plus the newer Fable 5.2 and Mythos 5.2, all with a 1-million-token context window. Anthropic’s standard rates put Opus 5.5 at $4 per million input tokens and $20 per million output, Sonnet 5.5 at $2 and $10, and Fable 5.2 at $8 and $40 — prices checked 19 November 2026 against Anthropic’s rates as tracked by secondary sources, and the pricing page is the authority if they have moved. Our guide to the Claude models covers the family in full, including the Fable and Mythos tiers; this section is only about how Claude sits inside Foundry.

The open-weight models are the other half of the catalogue, and they are where Foundry’s breadth shows most clearly. Llama from Meta, Mistral, DeepSeek, Qwen, Kimi’s K3 family and xAI’s Grok are all deployable from the same catalogue, and Microsoft added Kimi K3.1 Pro — Moonshot’s 2.8-trillion-parameter flagship — to Foundry in November 2026, as we reported at the time. Our guides to DeepSeek and Qwen cover two of the most-used open families in detail. The practical difference from the frontier models is control: open-weight models can be fine-tuned more freely, run in more deployment types, and in some cases self-hosted, which is why teams with strict data requirements or specialised tasks often pick them over a frontier model that is more capable in general but less flexible in particular.

One absence in the catalogue is as important as everything in it. Gemini is not on Foundry. Google’s Gemini 4 family — Argon, Carbon and Hydrogen, the last of which shipped on 12 November 2026 — runs on Google’s cloud only. An independent comparison of the three clouds’ own catalogues, published 21 October 2026, found no Gemini model listed on either Foundry or Amazon Bedrock, while Google’s own Model Garden lists Gemini 4 Argon and Gemini 3.8 Flash as generally available alongside Claude and, in private preview, GPT-6. Google announced on the same day that it was the only hyperscaler selling all three leading closed model families, and on its own terms the claim holds. For a buyer, the consequence is concrete: if Gemini is your primary model, Foundry is the wrong platform, and no amount of catalogue breadth changes that. Our guide to the Gemini models covers the family, including the Gemini 4 tiers, for readers who need to compare.

There is also a practical tool worth knowing about. Foundry’s Model Router picks from 35 models — eight of them added in October 2026, including Claude Opus 5 and Sonnet 5 — routing each request to the model best suited to it. It is the answer to the question every team asks after a month on the platform: which model should this request go to? Rather than hard-coding one model for everything, the router lets the platform decide per request, which is cheaper than running the frontier model on every task and better than running the small model on the tasks it cannot do. It is a small feature with an outsized effect on the bill, and it is covered again in the pricing section.

Microsoft’s Own Models: The MAI Family

A small workshop inside a large factory, a home-grown model line being built beside bigger machines, in-house models. No text.

The most significant change to Azure AI in 2026 is one the idea for this guide, written on 31 October, does not mention at all: Microsoft now builds its own models. The MAI family, launched at Microsoft Build in June 2026, is the in-house line from Microsoft AI, the organisation led by Mustafa Suleyman since March 2024, and it sits in the Foundry catalogue alongside OpenAI’s and Anthropic’s models. Microsoft is no longer only the shop that sells other people’s models. It is a model builder too, and that changes the strategic picture — even though, as of November 2026, most MAI models are still in preview and none of them is a frontier language model.

The family, as listed on Microsoft’s own model catalogue and checked against Microsoft Learn on 16 November 2026, has six lines. MAI-Thinking-1 is the reasoning model, a sparse mixture-of-experts design with about 35 billion active parameters and roughly 1 trillion total, trained on 30 trillion tokens. MAI-Code-1.1-Flash is the coding model, and it is the most widely deployed of the family: it is a model choice inside GitHub Copilot, VS Code and the Copilot CLI, where Microsoft says it scored 51.2% on SWE-Bench Pro against Claude Haiku 4.5’s 35.2% while using up to 60% fewer tokens — Microsoft’s own account, not an independent measurement. MAI-Image-2.6 is the image model, with a Flash variant for efficiency, and MAI-Voice-2.1 and MAI-Transcribe-2 cover speech generation and transcription. A sixth line, MAI-Cyber-1-Flash, is listed in the catalogue for cybersecurity work. Our guide to GitHub Copilot covers the coding side, including where MAI-Code sits in the model picker.

The honest way to describe the MAI family in November 2026 is: real, shipping, and not yet frontier. MAI-Thinking-1 and MAI-Image-2.6 are Foundry Models sold by Azure, in preview. MAI-Voice and MAI-Transcribe run through Azure Speech in Foundry Tools, in public preview. MAI-Code is not an API product you deploy at all — it is a model you select inside GitHub Copilot, where it sits beside OpenAI, Anthropic and Google models. Preview status matters more for production planning than any capability claim: no SLA, a default quota of zero, no provisioned throughput. And the next frontier model, MAI-Base-2 — a mixture-of-experts model with 80 billion active and 2.8 trillion total parameters, which Microsoft has finished pre-training — is still in post-training, with no release. It is a base model, not a product, and anyone planning around it is planning around a date Microsoft has not given.

Why does Microsoft bother, when it already sells the best models in the world? Three reasons, all visible in the catalogue. First, cost: a model Microsoft trains and runs itself is cheaper per token than a model it licenses, and the MAI voice and transcription prices — $22 and $15 per million characters for MAI-Voice-2.1 and its Flash variant, $0.10 per hour of audio for MAI-Transcribe-2 at its introductory rate — are set to undercut the alternatives. Second, independence: every MAI model is one less dependency on a partner whose roadmap Microsoft does not control. Third, integration: MAI models are tuned for Microsoft’s own products — Copilot, PowerPoint, OneDrive, GitHub — where a general model is good but a specialised one is better. The MAI family is not a replacement for GPT-6 or Claude on Azure. It is the house brand on the shelf beside them, and for the tasks it is tuned for, it is increasingly the sensible pick.

Foundry Agent Service: From a Model Call to an Agent

A helpful robot assistant with several tools laid out on a desk, a wrench, a magnifier, a phone, doing multi-step work. No readable text.

A model call is a question and an answer. An agent is a model that does a job. The difference is everything that sits around the model — instructions, tools, memory, retrieval, and the ability to keep going when the first step does not work — and Foundry Agent Service is the managed runtime that provides all of it. It has been generally available since Build in May 2025, and it is where Microsoft has spent most of its Foundry release notes in 2026. If you only need to send prompts to a model with no tools or orchestration, Microsoft’s own advice is to start with a single model call and not build an agent at all. The agent service is for the work that needs more.

The service offers three ways to build, on a spectrum from declarative to full code. A prompt agent is the declarative end: you specify instructions, choose a model, and attach tools in the Foundry portal or with the SDK, and Foundry hosts and runs the agent for you, with no application code or containers to maintain. A voice-based prompt agent is the same idea for real-time spoken experiences, configured with a model, instructions, audio settings and an optional greeting, then connected through Voice Live, with Foundry managing the lifecycle and voice orchestration. A hosted agent is the code end: you bring your own code or framework — Microsoft Agent Framework, LangGraph or Semantic Kernel — package it as a container, and Foundry runs it with a managed endpoint, scaling, identity and observability. The progression is deliberate: start declarative, and move to code when the agent outgrows what declarations can express.

What makes an agent useful is its tools and knowledge, and Foundry’s Toolbox is the way they are attached. Built-in tools cover web search, file search, code interpreter and memory; custom tools come through function calls, OpenAPI specs and MCP servers. Memory is a first-class feature, not an afterthought: the agent can remember across sessions, with short-term and long-term memory as metered services. Retrieval — looking up facts in your own data through Azure AI Search — is built in, so an agent can answer from your documents rather than from its training data. And in October 2026 Microsoft put its own Copilot harness into the Agent Service as a public preview: the managed harness that runs the agent loop for you, with skills and recovery from interruptions, free to run until 1 December 2026 according to secondary reporting. That harness is the clearest sign of where Foundry is heading: the platform increasingly runs the agent loop itself, and the developer’s job moves up a level, from writing the loop to describing the job.

The development cycle around the agent is as important as the agent itself. Foundry provides built-in evaluators that score quality (coherence, fluency), retrieval (groundedness, relevance), safety (hate and unfairness, violence, protected material) and agent behaviour (tool-call accuracy, task completion), and tracing built on OpenTelemetry that lands in Application Insights, so you can see what the agent did, step by step, and where it went wrong. That observability is the difference between an agent you can ship and an agent you can only demo. A demo agent that works nine times out of ten is a success; a production agent that fails one time in ten is a support ticket, a wrong answer to a customer, or a leaked document. The evaluation and tracing tooling exists because Microsoft’s enterprise customers asked for it, and it is the part of the platform that most distinguishes Foundry from a bare model API.

One more piece of the agent story belongs here because it is easy to miss. Foundry can be driven from coding agents — GitHub Copilot or Claude Code, for example — through the Foundry Skill and an MCP server, so the agent that builds your software can also provision and manage your Foundry resources. And Microsoft’s own Agent Framework, the open-source framework for building agents that runs on Foundry, is the same package that was hijacked on PyPI in November 2026 to steal Azure keys — a reminder, covered in our news report, that the agent ecosystem’s supply chain needs the same care as any other. The framework is a tool, not a guarantee, and the controls in the next sections are what make it safe to use.

Foundry Tools: Speech, Vision, Documents and the Rest

A set of specialist instruments on a workbench, an eye, an ear, a document and a shield as abstract shapes, the tools layer. No text.

Before there was a platform, there were services, and the services are still there — renamed, but doing the same jobs. Foundry Tools is the current name for what used to be Azure AI Services, and it is the layer of specialist capabilities that do one job well. A language model can read a document, but Document Intelligence reads it faster, cheaper and with structured output. A language model can transcribe speech, but the Speech service does it in real time, in dozens of languages, with speaker identification. The tools are the reason a production application on Azure is rarely “just a model”: the model is the reasoning, and the tools are the senses.

Speech is the most mature of the tools, and it covers the full loop: speech-to-text, text-to-speech, translation, and speaker recognition. Microsoft’s own MAI-Voice and MAI-Transcribe models now run through the Speech service, which is where the MAI family’s voice lines live in practice. Vision covers image analysis, object detection, optical character recognition and video analysis — the service that reads a photograph, a scanned form or a security-camera feed and turns it into structured data. Document Intelligence is the service that extracts text, tables, key-value pairs and layout from documents: invoices, contracts, forms, receipts, the paperwork that businesses actually run on. Language covers the text tasks that do not need a frontier model: sentiment, key-phrase extraction, entity recognition, summarisation, translation. Content Safety is the filter: it checks text and images against harm categories and configurable thresholds, and it is the same filtering that sits in front of Azure OpenAI by default. Translator is the translation service, covering text and documents across languages.

The tools are billed separately from the models, which is the one pricing fact in this section that matters: Foundry has no price of its own, and each tool has its own meter. A speech-heavy application pays mostly for Speech; a document-heavy one pays mostly for Document Intelligence. That separation is also the reason the tools layer is easy to underestimate in a budget — the model bill is the visible one, and the tools bill is the one that grows quietly as usage scales. The pricing section below gives the structure; the point here is that the tools are not free, and a cost model that only counts model tokens is incomplete.

The tools also have a second role that is easy to miss: they are the compliance boundary. Content Safety is not only a feature for your users; it is the control that lets an administrator say what the platform will and will not produce, with thresholds set per project. Document Intelligence keeps document processing inside Azure rather than sending paperwork to a third-party service. Speech keeps voice data inside the same boundary. For a regulated business, the tools layer is often the reason the whole application stays on Azure rather than splitting across vendors — and that, again, is the deal Azure AI sells.

The Foundry Walkthrough: Your First Project, Step by Step

A staircase of stepping stones leading up to a door, a first-project path, a walkthrough. No text.

Enough of the map. Here is the walkthrough: the path from nothing to a working agent, in the order Microsoft’s own documentation recommends, with the decisions you actually have to make at each step. No code in this section — the point is the decisions, not the syntax, and the SDKs, the CLI and the portal all implement the same path.

Step one is the account and the resource. You need an Azure account, and then a Foundry resource — one resource, in one region, in your subscription and resource group. The region matters more than it looks: not every model is available in every region, and the deployment type you choose later (global, data zone or regional) decides where your prompts are processed. Pick the region closest to your data and your users, and check the model availability page for the models you plan to use before you commit. If you already have an Azure OpenAI resource, Microsoft provides an upgrade path that preserves your endpoint, API keys and existing state — you do not start over.

Step two is the project. Inside the resource, create a project: the workspace where your team builds. A project holds your models, your agents, your data connections and your evaluations. Set the access control at the resource level first — who can use which model, from which network — and let the projects inherit it, rather than setting permissions per project and discovering the gaps later. Connect your data at this stage too: Azure AI Search for retrieval, your storage for files, your databases for grounding. An agent without data connections is a model with instructions; the connections are what make it useful.

Step three is the first model call. Before building anything, send a prompt to a model through the portal playground or the SDK, and confirm the round trip works: the endpoint, the key or Entra identity, the model deployment, the response. Microsoft’s recommended path puts this first for a reason — it is the step that catches the misconfigurations (wrong region, wrong deployment name, missing role assignment) while they are still cheap to fix. Choose the model deliberately: GPT-6.1 Sol for general work, a smaller model for high-volume simple tasks, a reasoning model for the hard ones. The model-choice section at the end of this guide gives the decision framework; for the first call, any current model will do.

Step four is the first agent. Build a prompt agent in the portal: write the instructions, pick the model, attach one tool — file search over your own documents is the usual first choice — and test it against real questions from your team. Then add memory and retrieval, and run the built-in evaluators against a set of test questions before anyone outside the team sees it. The evaluators score quality, groundedness and safety, and the tracing shows you where the agent went wrong, which is the information you need to improve the instructions rather than blaming the model.

Step five is the move to code, when the agent outgrows the portal. The SDKs cover Python, C#, JavaScript and Java; the Azure Developer CLI scaffolds, runs, tests and deploys hosted-agent projects from the command line; the VS Code extension lets you build and debug in your editor; and the Foundry Skill and MCP server let a coding agent drive Foundry for you. The new unified project client (azure-ai-projects 2.x) and the single project endpoint replace the old world of multiple packages against five or more endpoints — another detail that changed with the rename, and another reason old tutorials mislead. Ship it, monitor it through the built-in dashboards, and iterate on the evaluations, not on vibes. That is the whole walkthrough, and it is deliberately boring: the platform’s job is to make the boring parts reliable, so your team’s energy goes into the instructions and the data, which are the parts that decide whether the agent is any good.

What It Costs: Pricing, PTUs and the Batch Discount

A meter and a stack of coins beside a tap, paying for what you use, the pricing idea. No readable numbers.

Azure AI pricing has a reputation for being complicated, and the reputation is earned — but the structure underneath is simple, and once you see the structure the price list becomes navigable. There are three ways to pay for a model, three deployment types that change the price, and a handful of cost traps that catch everyone once. This section gives you the structure and one verified anchor price. It does not give you a price list, because the price list changes and the Azure pricing page is the authority.

The three ways to pay are Standard, Provisioned and Batch. Standard is pay-as-you-go: you pay per million input tokens and per million output tokens, with cached input — tokens you have sent before and that the system still holds — billed at a lower rate, and cache writes billed separately. It is the default, and it is the right choice for variable workloads and for anything you are still testing. Provisioned, billed in Provisioned Throughput Units (PTUs), is reserved capacity: you allocate throughput, pay a predictable amount for it, and get guaranteed capacity in return, with monthly and annual reservations available to reduce the overall spend. It is the right choice for a production workload with steady traffic, where a throttled request is a failed request. Batch is the third way: language models are available through a Batch API for global deployments, which returns completions within 24 hours for a 50% discount on Global Standard pricing. It is the right choice for anything that does not need an answer now — bulk classification, overnight summarisation, evaluation runs, data labelling — and it is the cheapest way to use a frontier model by a wide margin.

The three deployment types — global, data zone and regional — decide where your prompts are processed, and they change the price. Global deployment routes traffic across regions for capacity; data-zone deployment keeps processing inside a geographic zone, EU or US; regional deployment pins it to a local region, with up to 27 regions available. Data residency is the reason to choose anything other than global, and the price difference is the cost of that residency. The pricing page lists every model in every deployment type separately, which is why it is so long, and why quoting a single price for a model without naming the deployment type is meaningless.

The one anchor price this guide quotes is GPT-6.1 Sol, the workhorse of the current line-up: $2.00 per million input tokens and $10.00 per million output tokens, with cached input at $0.10, checked 19 November 2026 against the Azure pricing page as recorded by our earlier verification. Treat it as an anchor, not a quote: Microsoft can change it, and the pricing page is the authority if it has moved. The Claude prices in the catalogue section — Opus 5.5 at $4/$20, Sonnet 5.5 at $2/$10 — are Anthropic’s standard rates, billed through the Marketplace. Everything else in the price list, from GPT-6.2 Astra down to the embedding models, should be read on the pricing page itself before you budget around it. A guide that prints a full price list is out of date the week it is published; a guide that teaches you to read the pricing page stays useful.

Finally, the cost traps. Long context is the first: the long-context version of a model costs more than the short-context version, and a 1-million-token context window is only cheap if you do not fill it — every token you send is billed, including the ones the model does not need. Cached input is the second: it is dramatically cheaper, but only if your prompts repeat enough for the cache to hit, which means structuring prompts with a stable prefix and a changing suffix. Agent compute is the third: an agent that calls a model ten times to answer one question costs ten times the model price, plus the tools, the memory and the retrieval — the agent bill is not the model bill, and it is the one that surprises teams. And the fourth trap is the simplest: the model is not the only meter. Foundry Tools, Azure AI Search, storage, Application Insights and the supporting services all bill separately, and a cost model that only counts model tokens is incomplete by design. Budget for the platform, not the model.

Enterprise Controls: Data, Security and Compliance

A fortress wall with a gate and a guard, a shield over a data centre, enterprise controls. No text.

Everything in this guide so far has been about what Azure AI can do. This section is about what it will not do — or rather, what it lets you stop it from doing. Enterprise controls are the reason a bank, a hospital or a government department buys Azure AI instead of an API key, and they are the part of the platform that is hardest to evaluate from the outside, because they only become visible when something goes wrong. Here is what they actually are, in plain language.

The data controls start with the rule from the Azure OpenAI section: your prompts, completions, embeddings and training data are not available to other customers or to the model providers, and are not used to train foundation models without your permission or instruction. On top of that sits the abuse-monitoring arrangement — automated review of flagged prompts and completions, with human review by authorised Microsoft staff where needed, held in a per-customer store — and the option for managed customers to apply for modified abuse monitoring, under which prompts and completions are not stored for abuse monitoring or reviewed by humans. Encryption is AES-256 at rest by default, with the option of a customer-managed key, and data in transit is encrypted. The Responses API and other stateful features store message history in your own Azure tenant, which you can delete at any time. The honest summary: Microsoft holds your data to run the service and to police abuse, and no more than that, unless you ask it to hold more.

The access controls are Entra identity and role-based access control, applied once at the Foundry resource level and inherited by every project inside it. That unification is the practical benefit of the single-resource model: one place to say who can deploy a model, who can call it, who can read the evaluations and who can change the content filters, instead of repeating those decisions for every service. Network isolation comes through Private Link and virtual-network integration, so the resource can be reached only from your networks, and Azure Policy lets administrators enforce rules across the whole estate — which models are allowed, which regions, which deployment types. Content filters are configurable per deployment, with thresholds for the harm categories, and they apply to both prompts and outputs.

The compliance story is the Azure compliance story, inherited wholesale: the certifications, the audit reports, the data-protection addendum, and the BAA coverage for HIPAA workloads that enterprise guides report. Foundry’s control plane adds one more layer that is specific to AI: evaluations and tracing, which give an administrator evidence that an agent behaved — the prompts, the tool calls, the retrieval results, the scores — rather than an assurance that it probably did. That evidence is what a regulated business needs when an auditor asks how an AI system made a decision, and it is the control that most distinguishes a managed platform from a bare API. A bare API can tell you what you spent. Foundry can tell you what your agent did, and why.

There are limits, and an honest guide names them. Claude on Foundry is a partner model, so its support and service levels are Anthropic’s, not Microsoft’s, and its data is processed by Anthropic, not Microsoft — the “hosted on Azure” option narrows that gap but does not close it. Preview models carry no SLA and a default quota of zero. And the controls are only as good as their configuration: a Foundry resource with public network access, broad role assignments and default content filters is barely more controlled than a bare API key, and the platform will not save an administrator who does not use it. The controls are the reason to buy Azure AI. Using them is still your job.

The Infrastructure Underneath: Maia, Regions and Capacity

A vast hall of server racks with a single glowing chip at the centre, the infrastructure underneath. No text.

Underneath the platform is hardware, and the hardware is where Microsoft’s long game is most visible. Azure AI runs on a mix of NVIDIA GPUs, AMD accelerators and Microsoft’s own silicon, and the mix is shifting. The centrepiece is Maia, Microsoft’s custom AI accelerator. Maia 200 is already serving production workloads, including Microsoft Copilot, with more deployments for GitHub Copilot and Microsoft Foundry planned by the end of 2026. Maia 300, an inference-first system designed for long-context reasoning, conversational models and extended agent workflows, is scheduled to begin production deployments in 2027. Microsoft projects that Maia 300 will deliver 40% more tokens per megawatt than leading GPU-based systems, and up to seven times Maia 200’s rack-scale token throughput in a full 96-accelerator configuration — projections, not verified production results, and they should be read as Microsoft’s claim about its own roadmap, not as a benchmark.

For a buyer, the hardware matters in two concrete ways. The first is capacity: not every model is available in every region, and the deployment type you choose — global, data zone or regional — is partly a capacity decision, not only a residency one. Global deployment exists because it lets Microsoft route your traffic to wherever the capacity is; regional deployment is the price of pinning it down. If a model you need is not available in your region, the answer is usually a different deployment type or a different region, not a different platform, and the model-availability pages are the place to check before you design around a model. The second is cost: custom silicon is how Microsoft brings the per-token price down over time, and the MAI models’ aggressive pricing is only possible because they run on hardware Microsoft controls. The infrastructure is not a detail for the curious; it is the reason the price list looks the way it does.

The other infrastructure fact is how fast it all moves, and this guide’s own dates prove it. The o-series reasoning models retire today, 19 November 2026. Claude Sonnet 4.5 retires on 30 November 2026 on the Claude API, Google Cloud and Microsoft Foundry — though Amazon Bedrock keeps it until 8 April 2027 — with Sonnet 5.5 as the replacement. GPT-6.2 arrived two days before this guide was checked. The MAI family is a few months old and its versions change every few weeks. A guide to Azure AI is a snapshot, and the honest way to use one is to treat the structure as durable and the specifics as perishable: the layers, the deployment types, the data rules and the control plane change slowly, while the model names, the prices and the retirement dates change constantly. Check the Learn pages and the pricing page before any production decision, and treat any guide — including this one — as the map, not the territory.

Verdict: Who Azure AI Is For — and Who Should Look Elsewhere

A crossroads with two signposts, one path leading to a cloud city and one to a different road, the decision. No readable words.

Azure AI is for one kind of buyer above all: an organisation that already lives on Azure, or that needs its AI inside an enterprise boundary. If your data cannot leave your company, if your auditors need evidence of what an agent did, if your access control is Entra and your network is a VNet, if your bill already runs through a Microsoft agreement — then Foundry is not merely a good choice, it is the obvious one, and the catalogue breadth, the agent service and the controls are all reasons to stay. The platform’s weaknesses — the complexity, the price-list sprawl, the pace of change — are the price of that fit, and for this buyer they are worth paying.

It is also for the team that wants a hedge. The catalogue is the hedge: GPT-6 today, Claude tomorrow, an open model next quarter, a Microsoft model for the specialised task, all under one contract and one control plane. The Model Router makes the hedge automatic, and the evaluations make it safe. If you are the kind of team that has been burned by betting on one model vendor, Foundry is the platform that lets you stop betting. That is a genuine advantage, and it is the reason the catalogue — not any single model — is the first thing this guide described.

Who should look elsewhere? Anyone whose primary model is Gemini, because Gemini is not on Foundry and no roadmap has been announced that would put it there. Anyone who wants the newest model the day it ships, because OpenAI’s direct API gets features first and Azure follows. Anyone who is an individual developer or a small team without an Azure agreement, because the direct APIs are simpler, cheaper to start, and faster to learn. And anyone who wants a finished chatbot rather than a platform for building one — that buyer wants Copilot, not Foundry, and our guide to Microsoft Copilot in 365 is the place to start. The old strategy piece on Microsoft’s AI empire is also worth reading for the business picture behind the platform — the three pillars of Azure, Copilot and the OpenAI partnership — though it is a strategy essay, not a service guide, and it predates the Foundry rename.

If you are the buyer Foundry is for, here is what to do first. Open the Foundry portal, create a resource and a project, and make your first model call with GPT-6.1 Sol — the workhorse, not the frontier — against a real question from your own work. Then build one prompt agent, grounded in your own documents through Azure AI Search, and run the evaluators against it before anyone outside your team sees it. That is a day’s work, and at the end of it you will know more about whether Azure AI fits your organisation than any guide can tell you, including this one. The platform is the map. The first project is the territory.

Checked 19 November 2026. Prices, model availability and retirement dates change; the Azure pricing page and Microsoft Learn are the authorities.

Sources

  • Microsoft Learn — “What is Microsoft Foundry?” (learn.microsoft.com/en-us/azure/ai-foundry/what-is-azure-ai-foundry) — read in full, 19 November 2026: rename chain, 10,000+ model catalogue, agent types, enterprise capabilities, developer surfaces, recommended path.
  • Microsoft Learn — “Use the Azure OpenAI Responses API” (learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses) — supported-models list, read 19 November 2026: GPT-6.2 Astra/Sol (2026-11-17), GPT-6.1 Terra/Sol, GPT-6 Luna/Sol/Astra, GPT-5.6 Sol/Terra, GPT-5.5, GPT-5.1 family.
  • Microsoft Azure — “Azure OpenAI Service pricing” (azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/) — read in full, 19 November 2026: Standard pay-as-you-go, Provisioned Throughput Units, Batch API 50% discount within 24 hours, Global / Data Zone / Regional deployment types, model series list, GPT-6 Astra description.
  • Microsoft Learn Q&A — “Azure OpenAI Data Privacy and Enterprise Features” — read 19 November 2026: customer data not used to train foundation models; data stays inside Azure; no interaction with OpenAI-operated services; abuse monitoring and exemption; Responses API history in the customer’s own tenant.
  • Microsoft Learn retirement schedule, via consistent secondary reads (7 and 15 November 2026): o-series retirement 19 November 2026 with GPT-5.6 replacements; Claude Sonnet 4.5 retirement 30 November 2026 on Foundry.
  • Anthropic’s standard rates via secondary trackers (LiteLLM Foundry pricing, 19 November 2026): Claude Opus 5.5 $4/$20, Sonnet 5.5 $2/$10, Fable 5.2 $8/$40 per 1M input/output tokens; Claude generally available on Foundry end June 2026, hosted on Azure or hosted on Anthropic.
  • Google Cloud announcement, 21 October 2026, and independent catalogue comparison of the three clouds’ own pages: Gemini not listed on Foundry or Bedrock; GPT-6 in Google Model Garden in private preview only.
  • Microsoft Learn notes on the Copilot renames, as reported August–November 2026: Microsoft 365 Copilot now named Microsoft Copilot; unified app at copilot.cloud.microsoft from 18 August 2026.
  • Microsoft AI model catalogue and Microsoft Learn, checked 16 November 2026 via secondary reads: MAI-Thinking-1, MAI-Code-1.1-Flash, MAI-Image-2.6, MAI-Voice-2.1, MAI-Transcribe-2, MAI-Cyber-1-Flash; preview status; MAI-Base-2 in post-training, no release.
  • Microsoft’s Maia announcements, October 2026, via secondary reporting: Maia 200 in production, Maia 300 production deployments from 2027, projected 40% more tokens per megawatt.
  • Model Router (35 models, eight added October 2026), the Copilot harness public preview (28 October 2026, runtime free until 1 December 2026), and the “approximately 50 new models published each month” figure: Microsoft Foundry October 2026 roundups via secondary reporting (baeke.info, 9 November 2026; TechFabric CTO guide, October 2026) — stated in this guide as reported, not as first-hand Microsoft reads.
  • GPT-6.1 Sol anchor price ($2.00/$10.00 input/output, $0.10 cached input per 1M tokens): verified against the live Azure pricing page by the C6 Gemini run, recorded in the evergreen ledger, 13 November 2026; re-checked as the current anchor 19 November 2026.

Share to: , and

Faheem R. Khattak

Senior automation engineer and AI marketing journo covering LLMs, algorithms, analytics, core updates, Bing search, and technical SEO.

0 Comments

Leave a Reply

Optional Take Tag:

🛡️ Spam protection: Honeypot + Time-Trap Active

This site uses Akismet to reduce spam. Learn how your comment data is processed.