Foundry is designed to make AI model selection a structured, low-friction process rather than guesswork.

Here’s how it helps:

• Single catalog with breadth of choice: Foundry offers more than 11,000 AI models, including foundation, frontier, open-source, and bring-your-own models from providers such as OpenAI, Mistral, Cohere, Meta, NVIDIA, xAI, and others.
• Filter by what you actually need: You can discover and filter models by task, provider, and capability (for example, NLP, multimodal, code, vision), then compare model and service costs side by side.
• Start from your use case: Foundry encourages you to begin with the business problem—such as real-time conversations, healthcare diagnostics, fraud detection, or predictive analytics—and then narrow down models based on required accuracy, latency, throughput, and cost.
• Benchmark and evaluate in one place: You can run standardized benchmarks and your own application-specific tests using Foundry’s evaluation tools, including general-purpose, RAG, and agent evaluators to assess quality, safety, and reliability.
• Iterative, low-risk experimentation: Foundry supports an iterative approach—prototype with one model, compare alternatives, and switch models without starting from scratch or writing new code.
• Model router for ongoing optimization: The Foundry model router can automatically select models based on factors like query complexity, cost, and performance, helping you maintain the best fit over time.

The result is a more confident, data-driven way to pick models that align with your use case, budget, and risk profile—rather than defaulting to a single “one-size-fits-all” option.

Mapping your use case to the right model starts with clarifying inputs, outputs, and constraints, then using Foundry to narrow the field.

Key questions to ask:

• What inputs will the model handle? For example, natural language, audio, images, video, or multimodal combinations.
• What outputs do you need? Text summaries, decisions, predictions, transcriptions, or structured data.
• How complex is the reasoning? Simple classification vs. multi-step reasoning, planning, or tool use.
• What precision and domain depth do you need? General knowledge vs. domain-specific expertise (for example, healthcare, finance, legal).
• What are your latency and throughput requirements? Real-time conversations and live experiences (like sports or customer support) often prioritize speed and affordability over maximum possible accuracy.
• What are your regulatory and safety needs? High-stakes scenarios (such as diagnostics or fraud detection) require strong controls around accuracy, interpretability, and compliance.

How Foundry supports this:

• Task-to-model mapping: Foundry’s Model Catalog lets you search and filter by task (for example, summarization, translation, code generation, retrieval-augmented generation) so you only evaluate models that are functionally aligned.
• Support for different model sizes: You can choose from large foundation models, right-sized small language models (SLMs), device-specific models, and ultra-lightweight nanomodels for edge and on-device scenarios.
• Customization options: Foundry highlights which models support fine-tuning, RAG, LoRA, adapters, and prompt tuning, so you can decide how much customization you need to reach your target performance.
• Real-world examples: Customer stories—such as the NBA using Azure OpenAI GPT-4o for real-time fan insights, or Mars Science Diagnostics using Mistral to improve veterinary diagnostics—show how different use cases map to different model families.

By answering these questions up front and using Foundry’s filters and evaluation tools, you can quickly narrow down to a short list of models that are technically and operationally aligned with your project.

Foundry is built to help you make explicit trade-offs between performance, cost, and safety instead of treating them as afterthoughts.

1. Performance and accuracy

• Define acceptable thresholds for latency, throughput, accuracy, precision, and recall based on your use case.
• Use Foundry’s evaluators to measure ground truth (correctness of answers) with metrics like exact match (EM), F1, recall, and precision.
• Assess semantic quality with textual similarity evaluators for tasks like summarization and translation.
• Run load testing in Foundry to simulate production workloads and ensure performance holds under real-world volume.
• Use A/B testing to compare different models or versions on your own scenarios and data.

2. Cost and resource management

• Evaluate each model’s compute requirements, memory footprint, and loading times to keep performance and cost in balance.
• Compare pricing models: Foundry supports token-based Pay-As-You-Go, provisioned throughput units (PTUs), third-party pricing, region-specific pricing, and discounts for certain usage patterns.
• For predictable workloads, consider 1-month or 1-year PTU reservations; some customers have reported savings of up to 70% with annual reservations.
• Use Microsoft Cost Management to monitor spend, identify trends, and catch potential overspending early.
• Start with open-source models or lower-cost tiers (such as the Developer Tier in Foundry) for experimentation, then scale to more powerful models as value is proven.

3. Safety, compliance, and consistency

• Leverage Foundry’s built-in security features and certifications to align with regulations such as GDPR and HIPAA.
• Use risk and safety evaluators to detect bias, hallucinations, and fairness issues before going to production.
• Choose deployment options that match your data requirements—cloud, hybrid, or local inferencing for data sovereignty.
• Apply Microsoft’s Responsible AI standard through Foundry’s tools for security, privacy, transparency, and accountability.
• Plan for stability by understanding how often models are updated and what version control and rollback options are available.

By combining these capabilities, Foundry helps you reimagine model selection as an ongoing optimization process—balancing impact, risk, and cost as your AI applications and agents evolve.