Skip to main content

Microsoft Foundry

Microsoft Foundry is a unified Azure platform-as-a-service offering for enterprise AI operations, model builders, and application development. This foundation combines production-grade infrastructure with friendly interfaces, enabling developers to focus on building applications rather than managing infrastructure.
Rebranding: Azure AI Foundry is now Microsoft Foundry. Screenshots and documentation are being updated to reflect this change.

What is Microsoft Foundry?

Microsoft Foundry unifies agents, models, and tools under a single management grouping with built-in enterprise-readiness capabilities including tracing, monitoring, evaluations, and customizable enterprise setup configurations. The platform provides streamlined management through unified Role-based access control (RBAC), networking, and policies under one Azure resource provider namespace.

Build Agents

Create AI agents tailored to your needs with custom instructions and advanced tools

Work with Models

Access cutting-edge AI models from multiple providers with consistent APIs

Deploy at Scale

Transform proofs of concept into production applications with enterprise features

Collaborate

Team-based development with shared resources and secure isolation

Key Capabilities

Multi-Agent Orchestration

Build advanced automation using SDKs for C# and Python that enable collaborative agent behavior and complex workflow execution.
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import AgentWorkflow

# Create a multi-agent workflow
workflow = AgentWorkflow(
    name="customer-support",
    agents=[
        {"id": "triage-agent", "role": "classifier"},
        {"id": "technical-agent", "role": "specialist"},
        {"id": "billing-agent", "role": "specialist"}
    ],
    orchestration="sequential"
)

# Workflow automatically routes between agents
result = client.workflows.run(workflow, input="Need help with billing")

Expanded Tool Access

Access the Foundry tool catalog (preview) with over 1,400 tools through public and private catalogs.
  • Code Interpreter: Execute Python code in a sandbox
  • Function Calling: Integrate custom business logic
  • File Search: Search through uploaded documents
  • Bing Search: Access real-time web information
  • Azure AI Search: Query indexed knowledge bases

Enhanced Memory Capabilities

Use memory to help your agent retain and recall contextual information across interactions.
from azure.ai.projects.models import MemoryConfiguration

# Configure agent memory
memory_config = MemoryConfiguration(
    type="semantic",
    retention_policy="session",  # or "permanent"
    max_tokens=4000
)

agent = client.agents.create(
    model="gpt-4",
    instructions="You are a personal assistant with memory.",
    memory=memory_config
)

# Agent remembers context across conversations
thread = client.agents.create_thread()
client.agents.create_message(thread.id, "user", "My name is Alice")
# ... later in conversation ...
client.agents.create_message(thread.id, "user", "What's my name?")
# Agent responds: "Your name is Alice"
Memory maintains continuity, adapts to user needs, and delivers tailored experiences without requiring repeated input.

Knowledge Integration

Connect your agent to a Foundry IQ knowledge base to ground responses in enterprise or web content.
from azure.ai.projects.models import KnowledgeBase

# Create knowledge base
kb = client.knowledge.create(
    name="company-docs",
    sources=[
        {"type": "azure_blob", "container": "documents"},
        {"type": "sharepoint", "site": "company-portal"},
        {"type": "web", "urls": ["https://company.com/docs"]}
    ]
)

# Attach to agent
agent = client.agents.create(
    model="gpt-4",
    instructions="Answer questions using company documentation.",
    knowledge_base_id=kb.id,
    citation_mode="inline"  # Include source citations
)
This integration provides reliable, citation-backed answers for multi-turn conversations.

Real-Time Observability

Monitor performance and governance using built-in metrics and model tracking tools.

Tracing

Track agent execution flow
  • Request/response pairs
  • Tool invocations
  • Token usage
  • Latency metrics

Evaluations

Measure agent quality
  • Accuracy metrics
  • Groundedness scoring
  • Safety checks
  • Custom evaluators

Monitoring

Production health
  • Real-time dashboards
  • Alert configuration
  • Cost tracking
  • Usage patterns

Project Types

Microsoft Foundry (classic) supports two types of projects: Designed for agent-centric development with the latest capabilities.
Available Features:
  • Agents (GA)
  • Models from Azure and Marketplace
  • Foundry SDK and API (full support)
  • OpenAI SDK compatibility
  • Evaluations (preview)
  • Playgrounds and datasets
  • Project files API
  • BYOK (Bring Your Own Key Vault)

Hub-Based Projects (Legacy)

Traditional projects with broader ML capabilities but limited agent features.
New agent features are only available on Foundry projects. Consider migrating from hub-based projects for access to the Foundry Agent Service GA.
Feature Comparison:
CapabilityFoundry ProjectHub Project
Agents✅ GA⚠️ Preview only
Azure OpenAI, DeepSeek, xAI✅ DirectVia connections
Marketplace models✅ DirectVia connections
Managed compute models
Foundry SDK/API✅ FullLimited
Prompt flow

Microsoft Foundry API and SDKs

The Microsoft Foundry API is designed specifically for building agentic applications and provides a consistent contract across model providers.

Available SDKs

pip install azure-ai-projects
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

client = AIProjectClient(
    credential=DefaultAzureCredential(),
    subscription_id="your-sub-id",
    resource_group_name="your-rg",
    project_name="your-project"
)

REST API

Access the full Foundry API via REST:
curl -X POST https://your-endpoint.openai.azure.com/openai/threads/runs \
  -H "api-key: $FOUNDRY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "assistant_id": "asst_abc123",
    "thread": {
      "messages": [
        {"role": "user", "content": "Hello, how can you help me?"}
      ]
    }
  }'

Model Catalog

Access a wide variety of models from multiple providers:

Azure Models (Direct Access)

  • Azure OpenAI: GPT-4, GPT-4 Turbo, GPT-3.5 Turbo, GPT-4o
  • DeepSeek: DeepSeek-V2, DeepSeek-Coder
  • xAI: Grok models

Marketplace Models

  • Meta: Llama 3, Llama 2
  • Mistral AI: Mistral Large, Mistral Medium
  • Cohere: Command, Embed
  • Stability AI: Stable Diffusion models
  • HuggingFace: Various open-source models

Model Router

Automatically route requests to the best available model:
from azure.ai.projects.models import ModelRouter

router = ModelRouter(
    models=["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"],
    strategy="cost_optimized",  # or "performance_optimized"
    fallback=True
)

agent = client.agents.create(
    model_router=router,
    instructions="You are a helpful assistant."
)

Deployment Options

Publish your agents to multiple platforms:

Microsoft 365

Integrate with Teams, Outlook, and other M365 apps

Teams

Deploy as Teams bots for enterprise collaboration

BizChat

Connect to business chat platforms

Containers

Containerized deployments for portability

Enterprise Features

Centralized AI Asset Management

Observe, optimize, and manage 100% of your AI assets in the Operate section:
  • Register agents from other clouds
  • Get alerts when agents or models require attention
  • Manage AI fleet health as it scales
  • Track usage and costs across all assets

Enhanced Enterprise Support

  • Microsoft Entra ID authentication
  • Azure Key Vault integration
  • Virtual network support
  • Private endpoints
  • Managed identities

Getting Started

1

Create a Foundry Resource

Sign in to the Microsoft Foundry portal and create a new workspace.
2

Create Your First Agent

Use the portal or SDK to create an agent with custom instructions and tools.
3

Test and Iterate

Use the playground to test your agent and refine its behavior.
4

Deploy to Production

Publish your agent to your chosen platform with monitoring enabled.

Quickstart Example

Create and run an agent in minutes:
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

# Initialize
credential = DefaultAzureCredential()
client = AIProjectClient(
    credential=credential,
    subscription_id="your-subscription-id",
    resource_group_name="your-resource-group",
    project_name="your-project"
)

# Create agent
agent = client.agents.create(
    model="gpt-4",
    name="customer-support",
    instructions="""You are a helpful customer support agent.
    Be friendly, concise, and always cite sources when providing information.""",
    tools=[{"type": "code_interpreter"}, {"type": "file_search"}]
)

# Create conversation thread
thread = client.agents.create_thread()

# Send message
message = client.agents.create_message(
    thread_id=thread.id,
    role="user",
    content="How do I reset my password?"
)

# Run agent
run = client.agents.create_run(
    thread_id=thread.id,
    agent_id=agent.id
)

# Wait for completion
run = client.agents.wait_for_run(thread.id, run.id)

# Get response
messages = client.agents.list_messages(thread.id)
for msg in messages:
    if msg.role == "assistant":
        print(msg.content)

Pricing

Microsoft Foundry pricing is based on the underlying products you consume:
  • Platform: Free to use and explore
  • Models: Pay per token (varies by model)
  • Compute: Pay for VM/GPU hours when used
  • Storage: Standard Azure Storage pricing
  • Tools: Some tools may have additional costs
The platform itself is free - you only pay at deployment level for the resources you actually use.

Region Availability

Foundry is available in most regions where Foundry Tools are available. For agentic features, check the region support documentation for availability. Recommended Regions:
  • East US
  • West Europe
  • Southeast Asia

Resources

Quickstart

Get started with your first agent

API Reference

Complete API documentation

VS Code Extension

Develop agents in your IDE

GitHub Samples

Browse code examples

Next Steps

Build docs developers (and LLMs) love