4 Foundry Deployment Types That Decide Azure AI Cost and Data Residency

Azure AI (Microsoft Foundry) is the unified Azure platform for models, agents, and prebuilt AI tools that developers and IT teams use to build production AI apps and agentic systems. Its primary use cases include retrieval-augmented generation (RAG) agents, speech and vision pipelines, and code assistants embedded in existing workflows. Every project decision (which deployment type, which region, which agent model) shifts cost, data residency, and who owns which piece of security. That last part trips up more teams than the AI itself.
TL;DR:
- Most organizations should use Provisioned Throughput reservations for steady, high-volume workloads to reduce per-token costs once they surpass pay-per-token billing.
- Deployments require careful subnet sizing, especially for hosted agents, as undersized subnets can cause capacity issues during production scaling.
- Content safety, incident logging, and tenant data filtering are critical responsibilities for teams managing PaaS deployments, not just Microsoft.
- Model and agent quotas vary by region and deployment type, making pre-deployment quota checks essential to avoid delays or capacity limits.
- Managed partner services are recommended for complex, multi-region, or compliance-driven deployments to handle infrastructure, security, and monitoring effectively.
Table of Contents
- What Is Microsoft Foundry and How Does It Fit Into Azure AI?
- Foundry Tools: Vision, Speech, Language, and More
- Choosing a Deployment Type: Standard, Provisioned, Batch, or Developer
- Hosted Agents, Prompt Agents, and Toolboxes
- Networking Foundry Agents: VNet, Subnets, and Private Endpoints
- Security and Responsible AI: Who Owns What
- Getting Started: A Staged Adoption Path
- Managing Costs: Pay-Per-Token vs. PTU Reservations
- Developer Tooling: SDKs, azd, and CI/CD
- Where Azure AI Shows Up Across Industries
- Limitations and Quotas You Should Plan Around
- Troubleshooting Common Azure AI Issues
- When It Makes Sense to Bring in a Managed Partner
- Get Help Deploying Azure AI the Right Way
- FAQ
What Is Microsoft Foundry and How Does It Fit Into Azure AI?
Microsoft Foundry is the platform Microsoft built to consolidate what used to be scattered across Azure OpenAI, Azure Cognitive Services, and separate agent frameworks into one control plane. Foundry Tools is the umbrella product name Microsoft now uses for the model catalog, agent service, and orchestration layer that used to require stitching together several portals.
Foundry gives you three things in one place:
- A model catalog spanning Microsoft-sold models (Azure OpenAI included) and third-party partner and community models
- A hosted agent service for running agentic workloads with managed identity and scaling
- A control plane for deployment, versioning, and governance across projects
Azure Machine Learning still matters, but for a different job. Reach for Azure ML when you are training custom models from your own data pipelines or running classic ML experimentation. Reach for Foundry when you are building on top of existing foundation models, wiring up agents, or standing up a RAG application. Most production AI apps built today never touch Azure ML directly. They consume models and tools through Foundry’s SDKs instead.
Foundry Tools: Vision, Speech, Language, and More
Foundry Tools is the collective name for Microsoft’s prebuilt AI capabilities, and picking the right one saves you from re-inventing solved problems with a general-purpose model. Each tool targets a specific input type and ships its own API surface:
- Azure Vision handles image classification, object detection, and OCR for scanned forms or product photos.
- Azure Speech covers speech-to-text, text-to-speech, and real-time translation for call centers and voice interfaces.
- Azure Language does sentiment analysis, entity extraction, and summarization for text-heavy workloads like support tickets.
- Azure Document Intelligence extracts structured data from invoices, receipts, and contracts with prebuilt and custom models.
- Translator delivers real-time and batch text translation across more than 100 languages.
- Content Understanding combines multimodal extraction (text, image, audio) into a single structured output pipeline.
Most Foundry Tools bill on consumption (per transaction or per character processed), which is separate from token metering on generative models. That distinction matters when a team assumes a document-extraction workload will show up on the same invoice line as their chat model spend. It won’t.
Choosing a Deployment Type: Standard, Provisioned, Batch, or Developer
Deployment type is the single decision that most affects your latency, cost per token, and where your data physically processes. Microsoft Foundry Models support four deployment types, and each maps to a different workload shape.
- Standard (pay-per-token) fits prototypes, low-volume apps, and workloads with unpredictable traffic.
- Provisioned Throughput (PTU) reserves dedicated capacity for steady, high-volume traffic where latency consistency matters more than per-token cost.
- Global Batch processes large asynchronous jobs (think: nightly document summarization for 50,000 records) at a discounted rate.
- Developer deployments are scoped for testing and non-production experimentation.
Beyond deployment type, you also choose a processing scope: global, data zone, or regional. Global routes requests wherever capacity exists, which is fastest to provision but offers the least residency control. Regional keeps everything inside one Azure region, and data zone sits in between, restricting processing to a defined geography (useful for organizations with cross-border data rules but not strict single-country mandates). Availability of specific models still depends on your billing account’s geography, and Canada Central and Canada East are active regions for most Microsoft-sold model deployments.
Hosted Agents, Prompt Agents, and Toolboxes
Foundry Agent Service runs two distinct agent types, and picking the wrong one for your workload creates real operational pain later. Hosted agents let you bring your own containerized code from Azure Container Registry, while Microsoft handles session isolation, sandboxing, scaling, and identity assignment. Prompt agents skip the container entirely. They’re fully managed and defined through configuration, which makes them faster to ship but less flexible for custom logic.
Toolboxes are how agents discover and call external tools through Model Context Protocol (MCP) endpoints. A few operational patterns matter here:
- Toolbox versions are immutable snapshots. Update the
default_versiononly after validating a candidate on a test endpoint. - Keep staging and production toolbox versions pinned separately so a rollout in one project doesn’t surprise agents running in another.
- Agent identity should run through Microsoft Entra ID with on-behalf-of token patterns rather than a single persistent service identity shared across every tool call.
Pro Tip: Treat every tool and retrieval output your agent receives as untrusted input, the same way you’d treat user-submitted form data. Per-action authorization checks catch confused-deputy problems before they become incident reports.
Teams exploring more advanced orchestration patterns sometimes benchmark their designs against outside agent frameworks; Kickass Online’s work on AI agents is one example of an external reference point for agent design conventions worth comparing against your own architecture.
Networking Foundry Agents: VNet, Subnets, and Private Endpoints
Agent workloads consume IP addresses differently than typical app services, and under-provisioning your subnet is one of the more common production surprises. Foundry gives you two VNet models to choose from.
Bring-your-own (BYO) VNet gives you full control over subnet layout, routing, and existing peering, but it puts sizing responsibility squarely on your team. Managed VNet hands subnet management to Microsoft, which is the safer default if you expect IP overlap with existing address space.
If you go BYO, size for the workload, not the app:
- Use a suitably sized delegated subnet for production deployments; smaller subnets can work for small, low-concurrency pilots.
- Remember that hosted agents allocate IP addresses per session, so concurrent session counts (not request counts) drive your address consumption.
- Route external calls through a single-tenant data proxy and private endpoints rather than public internet paths.
- Confirm firewall rules and DNS resolution reach both the Foundry control plane and any connected data stores before go-live.
Under-sizing a subnet during a pilot and forgetting to revisit it before scaling to production is one of the most common Foundry deployment failures teams report.
Security and Responsible AI: Who Owns What
The AI shared responsibility model draws a line between what Microsoft manages and what your team must configure, and that line moves depending on whether you’re running SaaS, PaaS, or IaaS. A SaaS Copilot deployment leaves you responsible for little beyond user access policy. A PaaS deployment through Foundry hands you more control and more obligation: content filtering configuration, prompt injection mitigation, and data handling policy all become your job.
Microsoft’s Well-Architected Framework guidance on responsible AI recommends building these practices in from the design phase rather than retrofitting them:
- Run iterative red team testing against your specific prompts and data, not generic benchmarks.
- Apply Azure AI Content Safety to filter harmful outputs before they reach users.
- Log model inputs and outputs for explainability and incident review.
- Detect and redact PII before it enters a prompt or gets logged.
For RAG applications serving multiple tenants, Microsoft’s architecture guidance recommends putting an API gatekeeper in front of retrieval calls and enforcing tenant filtering there rather than trusting model code to respect tenant boundaries. Querying a back-end vector store directly from model code, without that gatekeeper, is a common way tenant data leaks across boundaries in poorly designed multitenant systems.
Getting Started: A Staged Adoption Path
Microsoft’s own adoption guidance recommends a tiered path rather than jumping straight to custom model development, and it’s the path that keeps most teams out of trouble.
- Start with SaaS. Copilot solutions deliver productivity wins with minimal operational overhead. If your use case is covered here, don’t build custom.
- Move to PaaS when you need tailoring. Azure OpenAI and Foundry give you control over prompts, grounding data, and agent behavior once off-the-shelf Copilot isn’t enough.
- Reserve custom model work for teams with deep expertise. Training or fine-tuning your own models demands data science and security maturity most teams haven’t built yet.
Before your first Foundry project, confirm three prerequisites: a Microsoft Entra ID tenant with RBAC roles assigned (Foundry User or Foundry Owner depending on scope), a billing account whose region supports the models you need, and a resource group scoped for the project. A minimal first project needs one model deployment, one test endpoint, and a smoke test that exercises your actual prompt pattern, not a generic “hello world” call.
Managing Costs: Pay-Per-Token vs. PTU Reservations
Standard deployments bill pay-per-token, which is simplest for variable or low-volume traffic. Provisioned Throughput reserves fixed capacity and becomes cheaper than pay-per-token once your volume is steady and high enough to justify the reservation.
Global reservations can discount PTU costs across multiple regions, while regional reservations lock you to a single Azure region at a lower base rate. The sequencing matters more than people expect: measure your actual deployed PTU usage before purchasing a reservation. Buying a reservation before your deployments exist is a common way teams end up with capacity mismatched to real traffic.
- Use Azure Cost Analysis scoped to your Foundry resource group to help isolate model spend from other Azure services.
- Tag deployments by team or project to better identify which workload is driving cost in shared subscriptions.
- Monitor cost meters for token-based models, PTU reservations, and Foundry Tools consumption as separate categories.
Developer Tooling: SDKs, azd, and CI/CD
Foundry supports SDKs in Python, .NET, and JavaScript, covering model calls, agent orchestration, and toolbox management from your existing codebase. The azd developer CLI handles provisioning and deployment workflows without hand-crafting ARM templates for every environment. MCP endpoints expose your toolbox to any compliant agent runtime, not just Foundry’s own.
For CI/CD, a few habits separate stable rollouts from surprises:
- Pin toolbox versions in staging and promote to
default_versiononly after smoke tests pass on a dedicated test endpoint. - Instrument telemetry on every agent action, not just top-level requests, so you can trace a bad output back to the tool call that caused it.
- Automate tests that check agent behavior against known prompts, not just API uptime.
Where Azure AI Shows Up Across Industries
Healthcare organizations use Azure Document Intelligence to extract structured data from intake forms and insurance claims, cutting manual data entry that used to consume clinical staff time. Combined with Azure Language for clinical note summarization, it’s one of the more mature production patterns in the platform today.
Transportation and logistics operators lean on Azure Vision for damage detection in freight photos and Azure Speech for dispatch call transcription, feeding both into RAG agents that surface relevant historical incidents during active shipments. Research institutions use Foundry’s model catalog to run literature summarization pipelines against internal document repositories, pairing Azure Language’s extraction capabilities with a custom RAG layer over their own archives.
Financial services teams build customer service agents on top of Azure OpenAI models grounded in internal policy documents, using the multitenant RAG safeguards described earlier to keep customer data properly isolated by account. Retail and e-commerce teams use Content Understanding to process product images and descriptions together, generating structured catalog metadata at a scale manual tagging never reached.
What ties these together isn’t the industry. It’s the pattern: prebuilt Foundry Tools handle the narrow, well-defined extraction or classification task, while a generative model layered on top handles the reasoning, summarization, or conversation. Teams that try to force a single large model to do both jobs usually end up with worse accuracy and higher cost than teams that split the work across a Foundry Tool and a model deployment.

Limitations and Quotas You Should Plan Around
Every Azure AI subscription operates under quotas, and hitting one mid-project is a common cause of launch delays. Token-per-minute (TPM) and requests-per-minute (RPM) limits apply per model deployment and vary by region and model version, so a quota that comfortably covers your staging traffic can throttle production the moment real users show up.
Model availability is uneven by design. Newer models often launch in a handful of regions before wider rollout, and partner-sold models depend on your billing account’s geography, which means a model your colleague uses in one subscription may not appear in yours. Provisioned Throughput carries its own constraint: PTU is sold in fixed units, so very low-volume workloads may find the minimum reservation size uneconomical compared to pay-per-token.
Agent-specific limits add another layer. Hosted agents consume IP addresses per session, so a delegated subnet sized for pilot traffic can silently cap your production concurrency long before compute becomes the bottleneck. Toolbox and MCP endpoints also have version and connection limits that aren’t always obvious until a rollout hits them.

None of these limitations are unusual for a platform at this scale, and Microsoft raises most quotas on request for verified production workloads. The practical lesson is to check quota documentation for your specific model and region before committing to an architecture, rather than assuming your prototype’s limits will scale linearly with usage.
Troubleshooting Common Azure AI Issues
Most Foundry problems fall into a handful of repeatable categories. Deployment failures often trace back to region or quota mismatches. Check that your billing account’s geography actually supports the model you’re requesting before assuming a service outage.
Agent timeouts and dropped sessions frequently point to subnet exhaustion rather than model latency, especially in BYO VNet configurations that were sized for a pilot and never revisited. Reviewing IP utilization against concurrent session counts usually surfaces the problem faster than debugging the agent code itself.
Unexpected cost spikes typically come from one of two sources: a Standard deployment absorbing traffic that should have moved to a PTU reservation, or Foundry Tools consumption being miscategorized against the wrong project tag. Cost Analysis scoped by resource group and tag resolves most of these within minutes.
For anything that doesn’t resolve through documentation, Microsoft Learn’s Foundry documentation stays current with deployment type changes, and Azure support plans (from developer to premier tiers) provide direct escalation paths for production incidents. Community forums and Microsoft Q&A tend to surface fixes for common SDK and toolbox versioning issues faster than a formal support ticket for anything non-urgent.
When It Makes Sense to Bring in a Managed Partner
Building Foundry expertise in-house works well until compliance requirements, 24/7 monitoring needs, or multi-region scaling outpace your team’s bandwidth. Supraits brings SOC 2 Type II certified security practices and over 25 years of enterprise IT experience to engagements that typically cover migration planning, security hardening, and ongoing monitoring, with the kind of scalable, security-first infrastructure work that regulated industries depend on.
— Brandon
Get Help Deploying Azure AI the Right Way
Managed-services partners help teams handle Foundry’s shared-responsibility obligations without hiring a dedicated AI infrastructure team. These partners can fill the customer side: subnet sizing, identity configuration, content safety tuning, and 24/7 monitoring that catches a quota breach or agent failure before users notice.

If your team is past the prototype stage and heading toward production PTU reservations or multi-region deployments, that’s exactly where a managed partner earns its keep. Supraits’s managed cloud and networking services cover the infrastructure layer Foundry deployments depend on, while the cybersecurity services team handles the red teaming, monitoring, and compliance documentation that responsible AI deployment requires. Check the full services overview and reach out to scope what an Azure AI deployment looks like for your organization.
FAQ
Is Azure AI the Same as Copilot?
No. Copilot is a SaaS product built on top of Azure AI models, while Azure AI (through Microsoft Foundry) is the underlying platform developers use to build custom applications, agents, and RAG systems. Copilot suits quick productivity use cases; Foundry suits tailored, developer-built solutions.
Is Microsoft Azure AI Free?
Azure AI has a pay-as-you-go pricing structure, with Standard deployments billed per token and no flat free tier for production use. Some services offer limited free-tier quotas for testing, but production workloads on Foundry Tools, Azure OpenAI, or PTU reservations all carry consumption-based costs.
Which AI Tool Is Best for Azure?
There’s no single best tool. It depends on your input type: Azure Vision for images, Azure Speech for audio, Azure Language for text analysis, and Azure Document Intelligence for structured document extraction. Most production systems combine several Foundry Tools with a generative model rather than relying on one.
Does Azure Have Its Own AI?
Yes. Azure hosts Microsoft-sold models, including Azure OpenAI, alongside third-party partner and community models, all accessible through the Foundry model catalog. Availability of specific partner models depends on your billing account’s geography.
How Do I Secure an Azure AI Deployment?
Start with the AI shared responsibility model to identify what Microsoft manages versus what your team owns, then layer in content safety filtering, red team testing, and tenant isolation for any multitenant RAG system. Organizations without in-house security capacity often bring in a partner like Supraits to handle hardening and ongoing monitoring.
Recommended


